Пример #1
0
        //Constructs the document and places it in the provided state
        public NuGenDocument(DigitizeState state)
        {
            listeners = new List <NuGenImageListener>();

            pointSets     = new NuGenPointSetCollection();
            segments      = new NuGenSegmentCollection();
            transform     = new NuGenScreenTranslate(this);
            gridDisplay   = new List <GridlineScreen>();
            digitizeState = state;
            matchSet      = new NuGenMatchSet(pointMatchSettings);

            //load all of the settings
            NuGenDefaultSettings rSettings = NuGenDefaultSettings.GetInstance();

            coordSettings      = rSettings.CoordSettings;
            exportSettings     = rSettings.ExportSettings;
            segmentSettings    = rSettings.SegmentSettings;
            pointMatchSettings = rSettings.PointMatchSettings;

            gridRemovalSettings             = rSettings.GridRemovalSettings;
            gridDisplaySettings.initialized = false;
            gridDisplaySettings.gridSetX    = rSettings.GridDisplayGridSetX;
            gridDisplaySettings.gridSetY    = rSettings.GridDisplayGridSetY;

            discretizeSettings  = rSettings.DiscretizeSettings;
            backgroundSelection = rSettings.BackgroundSelection;
        }
Пример #2
0
        //Removes pixels around user defined gridlines
        private void RemoveGridlines(PixelState[,] pixels, NuGenScreenTranslate transform,
                                     CoordSettings coordSettings, GridRemovalSettings gridRemovalSettings, PixelState pxState)
        {
            if (transform.ValidAxes)
            {
                List <GridlineScreen> gridlines;
                gridlines = NuGenGridMesh.MakeGridLines(transform, coordSettings, gridRemovalSettings.gridMesh);

                foreach (GridlineScreen gridline in gridlines)
                {
                    int xStart = gridline.Start.X;
                    int yStart = gridline.Start.Y;
                    int xStop  = gridline.Stop.X;
                    int yStop  = gridline.Stop.Y;

                    if (Math.Abs(xStop - xStart) < Math.Abs(yStop - yStart))
                    {
                        //Vertical lines
                        RemoveGridlineVertical(pixels, xStart, yStart, xStop, yStop, gridRemovalSettings, pxState);
                    }
                    else
                    {
                        //Horizontal lines
                        RemoveGridlineHorizontal(pixels, xStart, yStart, xStop, yStop, gridRemovalSettings, pxState);
                    }
                }
            }
        }
Пример #3
0
        private static List <GridlineScreen> MakeGridTheta(NuGenScreenTranslate transform, CoordSettings coordSettings, GridMeshSettings gridMeshSettings)
        {
            int                   i;
            int                   xStartS, yStartS, xStopS, yStopS;
            double                thetaG = gridMeshSettings.startX;
            GridlineScreen        gridline;
            List <GridlineScreen> gridlines = new List <GridlineScreen>();

            for (i = 0; i < gridMeshSettings.countX; i++)
            {
                transform.XThetaYRToScreen(coordSettings, thetaG, gridMeshSettings.startY, out xStartS, out yStartS);
                transform.XThetaYRToScreen(coordSettings, thetaG, gridMeshSettings.stopY, out xStopS, out yStopS);

                gridline.Start.X = xStartS;
                gridline.Start.Y = yStartS;
                gridline.Stop.X  = xStopS;
                gridline.Stop.Y  = yStopS;
                gridline.R       = false;

                thetaG += gridMeshSettings.stepX;
                gridlines.Add(gridline); //Maybe not?
            }

            return(gridlines);
        }
Пример #4
0
        private static List <GridlineScreen> MakeGridX(NuGenScreenTranslate transform, CoordSettings coordSettings, GridMeshSettings gridMeshSettings)
        {
            int                   i;
            int                   xStartS, yStartS, xStopS, yStopS;
            double                xG = gridMeshSettings.startX;
            GridlineScreen        gridline;
            List <GridlineScreen> gridlines = new List <GridlineScreen>();

            for (i = 0; i < gridMeshSettings.countX; i++)
            {
                gridline = new GridlineScreen();
                transform.XThetaYRToScreen(coordSettings, xG, gridMeshSettings.startY, out xStartS, out yStartS);
                transform.XThetaYRToScreen(coordSettings, xG, gridMeshSettings.stopY, out xStopS, out yStopS);

                gridline.Start.X = xStartS;
                gridline.Start.Y = yStartS;
                gridline.Stop.X  = xStopS;
                gridline.Stop.Y  = yStopS;
                gridline.R       = false;

                gridlines.Add(gridline);

                if (coordSettings.xThetaScale == Scale.Linear)
                {
                    xG += gridMeshSettings.stepX;
                }
                else
                {
                    xG *= gridMeshSettings.stepX;
                }
            }

            return(gridlines);
        }
        public GridRemovalSettingsDialog(NuGenDocument doc)
        {
            this.settings = doc.GridRemovalSettings;
            this.originalImage = doc.OriginalImage;
            this.discretizeSettings = doc.DiscretizeSettings;
            this.transform = doc.Transform;
            this.bgColor = doc.BackgroundColor;
            this.coordSettings = doc.CoordSettings;

            if (doc.ValidAxes)
                this.gridRemovalMesh = doc.GridDisplaySettings;
            else
                this.gridRemovalMesh.initialized = false;

            discretizeSettings.discretizeMethod = DiscretizeMethod.DiscretizeForeground;

            InitializeComponent();
            InitializeDefaults();

            if (!(doc.ValidAxes || doc.ValidScale))
            {
                textBox1.Enabled = false;
                textBox2.Enabled = false;
                checkBox2.Enabled = false;
                checkBox2.Checked = false;
                checkBox3.Enabled = false;
                checkBox3.Checked = false;
            }

            histogram.ValueChanged = this.ValueChanged;

            ValueChanged(true);

            this.MaximumSize = Size;
        }
Пример #6
0
        // return bounds on the coordinates for just axis, or all, pointsets, and true if
        // there were any coordinates
        public bool AxisSetGraphLimits(CoordSettings coord, NuGenScreenTranslate transform,
                                       ref double xThetaMin, ref double xThetaMax,
                                       ref double yRMin, ref double yRMax)
        {
            UpdateGraphCoordinates(coord, transform);

            // get limits
            return(axesPointSet.PointSetGraphLimits(ref xThetaMin, ref xThetaMax, ref yRMin, ref yRMax));
        }
Пример #7
0
        private static List <GridlineScreen> MakeGridR(NuGenScreenTranslate transform, CoordSettings coordSettings, GridMeshSettings gridMeshSettings)
        {
            int                   i;
            int                   xStartS = 0, yStartS = 0, xStopS = 1, yStopS = 1;
            double                rG = gridMeshSettings.startY;
            GridlineScreen        gridline;
            List <GridlineScreen> gridlines = new List <GridlineScreen>();

            for (i = 0; i < gridMeshSettings.countY; i++)
            {
                gridline = new GridlineScreen();
                // for polar coordinates we simply piecewise define the elliptical arc until motivated
                // to implement a better drawing algorithm. segments will be evenly spaced in angle
                // some pdf documents describing alternative algorithms are found in the doc directory.
                // it would have been elegant to use QCanvasEllipses but those are axis-aligned.
                double delta = AngleSpacing(coordSettings.thetaUnits);
                bool   first = true;
                for (double angle = gridMeshSettings.startX; angle < gridMeshSettings.stopX; angle += delta)
                {
                    transform.XThetaYRToScreen(coordSettings, angle, rG, out xStopS, out yStopS);

                    if (first)
                    {
                        xStartS = xStopS;
                        yStartS = yStopS;
                    }
                    else
                    {
                        if (NuGenMath.VectorMagnitude(xStopS - xStartS, yStopS - yStartS, 0.0) >= pixelSpacing)
                        {
                            gridline.Start.X = xStartS;
                            gridline.Start.Y = yStartS;
                            gridline.Stop.X  = xStopS;
                            gridline.Stop.Y  = yStopS;
                            gridline.R       = true;

                            xStartS = xStopS;
                            yStartS = yStopS;
                        }
                    }

                    first = false;
                }

                if (coordSettings.yRScale == Scale.Linear)
                {
                    rG += gridMeshSettings.stepY;
                }
                else
                {
                    rG *= gridMeshSettings.stepY;
                }
            }

            return(gridlines);
        }
Пример #8
0
        // apply the transformation to set graph coordinates of the points in the curve and measure pointsets
        public void UpdateGraphCoordinates(CoordSettings coord, NuGenScreenTranslate transform)
        {
            foreach (NuGenPoint point in points)
            {
                double xTheta, yR;
                transform.ScreenToXThetaYR(coord, point.XScreen, point.YScreen, out xTheta, out yR);

                point.XThetaGraph = xTheta;
                point.YRGraph     = yR;
            }
        }
Пример #9
0
        private void InitializeThin(CoordSettings coordSettings, NuGenScreenTranslate transform, double thinThickness)
        {
            transform.XBasisScreen(coordSettings, out xBasisXS, out xBasisYS);
            transform.YBasisScreen(coordSettings, out yBasisXS, out yBasisYS);

            // initialize search patterns
            InitializeThinSearch(thinThickness, xBasisXS, yBasisXS, searchPatternPlusX);
            InitializeThinSearch(thinThickness, xBasisYS, yBasisYS, searchPatternPlusY);
            InitializeThinSearch(thinThickness, -xBasisXS, yBasisXS, searchPatternMinusX);
            InitializeThinSearch(thinThickness, xBasisYS, -yBasisYS, searchPatternMinusY);
        }
Пример #10
0
        // for curve pointsets connected as Single Valued Functions, since the graph coordinates
        // of all points are updated, we must reconnect any points that were reordered. remember,
        // a single valued function has only a single value per xTheta value, so the lines cannot overlap
        public void ForceSingleValued(CoordSettings coord, NuGenScreenTranslate transform)
        {
            // quick exit if pointset is a closed contour, which is the case for all axis, scale and
            // measure pointsets. curve pointsets may be either single valued functions, or closed contours
            if (style.lineConnectAs != LineConnectAs.SingleValuedFunction)
            {
                return;
            }

            // quick exit if points are already in order
            if (SingleValued(coord, transform))
            {
                return;
            }

            Comparison <NuGenPoint> comparison = new Comparison <NuGenPoint>(this.XThetaSort);

            // sort the points by xTheta
            points.Sort(comparison);

            // to prevent having to remove N lines and then immediately adding N lines, we only
            // adjust as many lines as necessary
            NuGenPoint pOld   = points[points.Count - 1];
            NuGenPoint pOlder = null;

            foreach (NuGenPoint pNew in points)
            {
                if (pOlder != null)
                {
                    if ((pOlder.NextLine != pNew.PreviousLine) || (pNew.PreviousLine == null))
                    {
                        if (pOlder.NextLine == null)
                        {
                            pOlder.NextLine = pOld.NextLine;
                            pOld.NextLine   = null;
                        }

                        pOlder.NextLine.start.X = pOlder.XScreen;
                        pOlder.NextLine.start.Y = pOlder.YScreen;
                        pOlder.NextLine.end.X   = pNew.XScreen;
                        pOlder.NextLine.end.Y   = pNew.YScreen;

                        pNew.PreviousLine = pOlder.NextLine;
                    }
                }
                else
                {
                    pNew.PreviousLine = null;
                }

                pOlder = pNew;
            }
        }
Пример #11
0
        private static List<GridlineScreen> MakeGridR(NuGenScreenTranslate transform, CoordSettings coordSettings, GridMeshSettings gridMeshSettings)
        {
            int i;
            int xStartS = 0, yStartS = 0, xStopS = 1, yStopS = 1;
            double rG = gridMeshSettings.startY;
            GridlineScreen gridline;
            List<GridlineScreen> gridlines = new List<GridlineScreen>();
            for (i = 0; i < gridMeshSettings.countY; i++)
            {
                gridline = new GridlineScreen();
                // for polar coordinates we simply piecewise define the elliptical arc until motivated
                // to implement a better drawing algorithm. segments will be evenly spaced in angle
                // some pdf documents describing alternative algorithms are found in the doc directory.
                // it would have been elegant to use QCanvasEllipses but those are axis-aligned.
                double delta = AngleSpacing(coordSettings.thetaUnits);
                bool first = true;
                for (double angle = gridMeshSettings.startX; angle < gridMeshSettings.stopX; angle += delta)
                {
                    transform.XThetaYRToScreen(coordSettings, angle, rG, out xStopS, out yStopS);

                    if (first)
                    {
                        xStartS = xStopS;
                        yStartS = yStopS;
                    }
                    else
                    {
                        if (NuGenMath.VectorMagnitude(xStopS - xStartS, yStopS - yStartS, 0.0) >= pixelSpacing)
                        {
                            gridline.Start.X = xStartS;
                            gridline.Start.Y = yStartS;
                            gridline.Stop.X = xStopS;
                            gridline.Stop.Y = yStopS;
                            gridline.R = true;

                            xStartS = xStopS;
                            yStartS = yStopS;
                        }
                    }

                    first = false;
                }

                if (coordSettings.yRScale == Scale.Linear)
                    rG += gridMeshSettings.stepY;
                else
                    rG *= gridMeshSettings.stepY;
            }

            return gridlines;
        }
Пример #12
0
        // apply the transformation to set graph coordinates of the points in the curves and
        // measures. if the operation could cause points to be reordered to keep a curve
        // single-valued then the optional update list should be used
        public void UpdateGraphCoordinates(CoordSettings coord, NuGenScreenTranslate transform)
        {
            // apply transformation
            foreach (NuGenPointSet pointSet in curveList)
            {
                pointSet.UpdateGraphCoordinates(coord, transform);
                pointSet.ForceSingleValued(coord, transform);
            }

            foreach (NuGenPointSet pointSet in measureList)
            {
                pointSet.UpdateGraphCoordinates(coord, transform);
            }
        }
Пример #13
0
        // true if pointset is single valued
        private bool SingleValued(CoordSettings coord, NuGenScreenTranslate transform)
        {
            bool   first = true;
            double xThetaLast = 0.0, xTheta, yR;

            foreach (NuGenPoint point in points)
            {
                transform.ScreenToXThetaYR(coord, point.XScreen, point.YScreen, out xTheta, out yR);

                if (!first && (xTheta < xThetaLast))
                {
                    return(false);
                }

                xThetaLast = xTheta;
                first      = false;
            }

            return(true);
        }
Пример #14
0
        public bool PointSetGraphLimits(CoordSettings coord, NuGenScreenTranslate transform,
                                        ref double xThetaMin, ref double xThetaMax,
                                        ref double yRMin, ref double yRMax)
        {
            // update and get axis limits
            bool first = AxisSetGraphLimits(coord, transform, ref xThetaMin, ref xThetaMax, ref yRMin, ref yRMax);

            SinglePointSetGraphLimits(scalePointSet, ref first, ref xThetaMin, ref xThetaMax, ref yRMin, ref yRMax);

            foreach (NuGenPointSet pointset in curveList)
            {
                SinglePointSetGraphLimits(pointset, ref first, ref xThetaMin, ref xThetaMax, ref yRMin, ref yRMax);
            }

            foreach (NuGenPointSet pointset in measureList)
            {
                SinglePointSetGraphLimits(pointset, ref first, ref xThetaMin, ref xThetaMax, ref yRMin, ref yRMax);
            }

            return(!first);
        }
Пример #15
0
        //Makes gridlines from the given translation
        public static List<GridlineScreen> MakeGridLines(NuGenScreenTranslate transform, CoordSettings coordSettings, GridMeshSettings gridMeshSettings)
        {
            List<GridlineScreen> list = new List<GridlineScreen>();
            if (transform.ValidAxes)
            {
                if (coordSettings.frame == ReferenceFrame.Cartesian)
                {
                    list.AddRange(MakeGridX(transform, coordSettings, gridMeshSettings));
                    list.AddRange(MakeGridY(transform, coordSettings, gridMeshSettings));
                    return list;
                }
                else
                {
                    list.AddRange(MakeGridTheta(transform, coordSettings, gridMeshSettings));
                    list.AddRange(MakeGridR(transform, coordSettings, gridMeshSettings));
                    return list;
                }
            }

            return list;
        }
Пример #16
0
        //Makes gridlines from the given translation
        public static List <GridlineScreen> MakeGridLines(NuGenScreenTranslate transform, CoordSettings coordSettings, GridMeshSettings gridMeshSettings)
        {
            List <GridlineScreen> list = new List <GridlineScreen>();

            if (transform.ValidAxes)
            {
                if (coordSettings.frame == ReferenceFrame.Cartesian)
                {
                    list.AddRange(MakeGridX(transform, coordSettings, gridMeshSettings));
                    list.AddRange(MakeGridY(transform, coordSettings, gridMeshSettings));
                    return(list);
                }
                else
                {
                    list.AddRange(MakeGridTheta(transform, coordSettings, gridMeshSettings));
                    list.AddRange(MakeGridR(transform, coordSettings, gridMeshSettings));
                    return(list);
                }
            }

            return(list);
        }
Пример #17
0
        public GridRemovalSettingsDialog(NuGenDocument doc)
        {
            this.settings           = doc.GridRemovalSettings;
            this.originalImage      = doc.OriginalImage;
            this.discretizeSettings = doc.DiscretizeSettings;
            this.transform          = doc.Transform;
            this.bgColor            = doc.BackgroundColor;
            this.coordSettings      = doc.CoordSettings;

            if (doc.ValidAxes)
            {
                this.gridRemovalMesh = doc.GridDisplaySettings;
            }
            else
            {
                this.gridRemovalMesh.initialized = false;
            }

            discretizeSettings.discretizeMethod = DiscretizeMethod.DiscretizeForeground;

            InitializeComponent();
            InitializeDefaults();

            if (!(doc.ValidAxes || doc.ValidScale))
            {
                textBox1.Enabled  = false;
                textBox2.Enabled  = false;
                checkBox2.Enabled = false;
                checkBox2.Checked = false;
                checkBox3.Enabled = false;
                checkBox3.Checked = false;
            }

            histogram.ValueChanged = this.ValueChanged;

            ValueChanged(true);

            this.MaximumSize = Size;
        }
Пример #18
0
        //Remove gridlines and reconnect gaps
        public void RemoveAndConnect(NuGenScreenTranslate transform, CoordSettings coordSettings, GridRemovalSettings gridRemovalSettings, Color bgColor)
        {
            int width  = bmp.Width;
            int height = bmp.Height;

            PixelState[,] pixels = InitializePixels();

            // 1) Color removal
            if (gridRemovalSettings.removeColor)
            {
                RemoveColor(pixels, gridRemovalSettings, PixelState.PixelOnRemovedStage1);
            }


            // 2) Remove pixels around gridlines
            if (gridRemovalSettings.removeGridlines && gridRemovalSettings.gridDistance > 0.0)
            {
                RemoveGridlines(pixels, transform, coordSettings, gridRemovalSettings, PixelState.PixelOnRemovedStage2);
            }

            // 3) Remove thin lines parallel to the axes
            if (gridRemovalSettings.removeThinLines && gridRemovalSettings.thinThickness > 0.0)
            {
                RemoveThinLines(pixels, coordSettings, transform, gridRemovalSettings.thinThickness,
                                PixelState.PixelOnRemovedStage3, PixelState.PixelOnRemovedStage4);
            }

            // Reconnect the gaps created from the prior steps
            if (gridRemovalSettings.gapSeparation > 0.0)
            {
                ConnectNeuronsAcrossGaps(pixels, gridRemovalSettings.gapSeparation);
            }

            //Write the image
            SavePixels(pixels, bgColor);

            //Save the image
            discretize.SetImage(bmp);
        }
Пример #19
0
        //Remove gridlines and reconnect gaps
        public void RemoveAndConnect(NuGenScreenTranslate transform, CoordSettings coordSettings, GridRemovalSettings gridRemovalSettings, Color bgColor)
        {
            int width = bmp.Width;
            int height = bmp.Height;

            PixelState[,] pixels = InitializePixels();

            // 1) Color removal
            if (gridRemovalSettings.removeColor)
            {
                RemoveColor(pixels, gridRemovalSettings, PixelState.PixelOnRemovedStage1);
            }


            // 2) Remove pixels around gridlines
            if (gridRemovalSettings.removeGridlines && gridRemovalSettings.gridDistance > 0.0)
            {
                RemoveGridlines(pixels, transform, coordSettings, gridRemovalSettings, PixelState.PixelOnRemovedStage2);
            }

            // 3) Remove thin lines parallel to the axes
            if (gridRemovalSettings.removeThinLines && gridRemovalSettings.thinThickness > 0.0)
            {
                RemoveThinLines(pixels, coordSettings, transform, gridRemovalSettings.thinThickness,
                    PixelState.PixelOnRemovedStage3, PixelState.PixelOnRemovedStage4);
            }

            // Reconnect the gaps created from the prior steps
            if (gridRemovalSettings.gapSeparation > 0.0)
            {
                ConnectNeuronsAcrossGaps(pixels, gridRemovalSettings.gapSeparation);
            }

            //Write the image
            SavePixels(pixels, bgColor);

            //Save the image
            discretize.SetImage(bmp);
        }
Пример #20
0
        private static List<GridlineScreen> MakeGridTheta(NuGenScreenTranslate transform, CoordSettings coordSettings, GridMeshSettings gridMeshSettings)
        {
            int i;
            int xStartS, yStartS, xStopS, yStopS;
            double thetaG = gridMeshSettings.startX;
            GridlineScreen gridline;
            List<GridlineScreen> gridlines = new List<GridlineScreen>();
            for (i = 0; i < gridMeshSettings.countX; i++)
            {
                transform.XThetaYRToScreen(coordSettings, thetaG, gridMeshSettings.startY, out xStartS, out yStartS);
                transform.XThetaYRToScreen(coordSettings, thetaG, gridMeshSettings.stopY, out xStopS, out yStopS);

                gridline.Start.X = xStartS;
                gridline.Start.Y = yStartS;
                gridline.Stop.X = xStopS;
                gridline.Stop.Y = yStopS;
                gridline.R = false;

                thetaG += gridMeshSettings.stepX;
                gridlines.Add(gridline); //Maybe not?
            }

            return gridlines;
        }
Пример #21
0
        private static List<GridlineScreen> MakeGridX(NuGenScreenTranslate transform, CoordSettings coordSettings, GridMeshSettings gridMeshSettings)
        {
            int i;
            int xStartS, yStartS, xStopS, yStopS;
            double xG = gridMeshSettings.startX;
            GridlineScreen gridline;
            List<GridlineScreen> gridlines = new List<GridlineScreen>();
            for (i = 0; i < gridMeshSettings.countX; i++)
            {
                gridline = new GridlineScreen();
                transform.XThetaYRToScreen(coordSettings, xG, gridMeshSettings.startY, out xStartS, out yStartS);
                transform.XThetaYRToScreen(coordSettings, xG, gridMeshSettings.stopY, out xStopS, out yStopS);

                gridline.Start.X = xStartS;
                gridline.Start.Y = yStartS;
                gridline.Stop.X = xStopS;
                gridline.Stop.Y = yStopS;
                gridline.R = false;

                gridlines.Add(gridline);

                if (coordSettings.xThetaScale == Scale.Linear)
                    xG += gridMeshSettings.stepX;
                else
                    xG *= gridMeshSettings.stepX;
            }

            return gridlines;
        }
Пример #22
0
        // apply the transformation to set graph coordinates of the points in the curve and measure pointsets
        public void UpdateGraphCoordinates(CoordSettings coord, NuGenScreenTranslate transform)
        {
            foreach (NuGenPoint point in points)
            {
                double xTheta, yR;
                transform.ScreenToXThetaYR(coord, point.XScreen, point.YScreen, out xTheta, out yR);

                point.XThetaGraph = xTheta;
                point.YRGraph = yR;
            }
        }
Пример #23
0
        private void InitializeThin(CoordSettings coordSettings, NuGenScreenTranslate transform, double thinThickness)
        {
            transform.XBasisScreen(coordSettings, out xBasisXS, out xBasisYS);
            transform.YBasisScreen(coordSettings, out yBasisXS, out yBasisYS);

            // initialize search patterns
            InitializeThinSearch(thinThickness, xBasisXS, yBasisXS, searchPatternPlusX);
            InitializeThinSearch(thinThickness, xBasisYS, yBasisYS, searchPatternPlusY);
            InitializeThinSearch(thinThickness, -xBasisXS, yBasisXS, searchPatternMinusX);
            InitializeThinSearch(thinThickness, xBasisYS, -yBasisYS, searchPatternMinusY);
        }
Пример #24
0
        //Removes pixels around user defined gridlines
        private void RemoveGridlines(PixelState[,] pixels, NuGenScreenTranslate transform,
            CoordSettings coordSettings, GridRemovalSettings gridRemovalSettings, PixelState pxState)
        {
            if (transform.ValidAxes)
            {
                List<GridlineScreen> gridlines;
                gridlines = NuGenGridMesh.MakeGridLines(transform, coordSettings, gridRemovalSettings.gridMesh);

                foreach (GridlineScreen gridline in gridlines)
                {
                    int xStart = gridline.Start.X;
                    int yStart = gridline.Start.Y;
                    int xStop = gridline.Stop.X;
                    int yStop = gridline.Stop.Y;

                    if (Math.Abs(xStop - xStart) < Math.Abs(yStop - yStart))
                    {
                        //Vertical lines
                        RemoveGridlineVertical(pixels, xStart, yStart, xStop, yStop, gridRemovalSettings, pxState);
                    }
                    else
                    {
                        //Horizontal lines
                        RemoveGridlineHorizontal(pixels, xStart, yStart, xStop, yStop, gridRemovalSettings, pxState);
                    }
                }
            }
        }
Пример #25
0
        //Removes thin lines which are parallel to the user defined axes
        private void RemoveThinLines(PixelState[,] pixels, CoordSettings coordSettings, NuGenScreenTranslate transform,
                double thinThickness, PixelState pixelStateRemovedPass1, PixelState pixelStateRemovedPass2)
        {
            if (transform.ValidAxes)
            {
                InitializeThin(coordSettings, transform, thinThickness);

                // first pass erases the gridMeshSettings lines, except for the junctions
                EraseThinPixels(pixels, thinThickness, pixelStateRemovedPass1);

                // second pass erases the gridMeshSettings line junctions, which are little islands of on-pixels
                EraseThinPixels(pixels, thinThickness, pixelStateRemovedPass2);
            }
        }
Пример #26
0
        // for curve pointsets connected as Single Valued Functions, since the graph coordinates
        // of all points are updated, we must reconnect any points that were reordered. remember,
        // a single valued function has only a single value per xTheta value, so the lines cannot overlap
        public void ForceSingleValued(CoordSettings coord, NuGenScreenTranslate transform)
        {
            // quick exit if pointset is a closed contour, which is the case for all axis, scale and
            // measure pointsets. curve pointsets may be either single valued functions, or closed contours
            if (style.lineConnectAs != LineConnectAs.SingleValuedFunction)
                return;

            // quick exit if points are already in order
            if (SingleValued(coord, transform))
                return;

            Comparison<NuGenPoint> comparison = new Comparison<NuGenPoint>(this.XThetaSort);                

            // sort the points by xTheta
            points.Sort(comparison);

            // to prevent having to remove N lines and then immediately adding N lines, we only
            // adjust as many lines as necessary
            NuGenPoint pOld = points[points.Count - 1];
            NuGenPoint pOlder = null;

            foreach (NuGenPoint pNew in points)
            {
                if (pOlder != null)
                {
                    if ((pOlder.NextLine != pNew.PreviousLine) || (pNew.PreviousLine == null))
                    {
                        if (pOlder.NextLine == null)
                        {
                            pOlder.NextLine = pOld.NextLine;
                            pOld.NextLine = null;
                        }

                        pOlder.NextLine.start.X = pOlder.XScreen;
                        pOlder.NextLine.start.Y = pOlder.YScreen;
                        pOlder.NextLine.end.X = pNew.XScreen;
                        pOlder.NextLine.end.Y = pNew.YScreen;

                        pNew.PreviousLine = pOlder.NextLine;
                    }
                }
                else
                {
                    pNew.PreviousLine = null;
                }

                pOlder = pNew;
            }
        }
Пример #27
0
        // true if pointset is single valued
        private bool SingleValued(CoordSettings coord, NuGenScreenTranslate transform)
        {
            bool first = true;
            double xThetaLast = 0.0, xTheta, yR;
            foreach(NuGenPoint point in points)
            {
                transform.ScreenToXThetaYR(coord, point.XScreen, point.YScreen, out xTheta, out yR);

                if (!first && (xTheta < xThetaLast))
                    return false;

                xThetaLast = xTheta;
                first = false;
            }

            return true;
        }
Пример #28
0
        //Deserialization constructor.
        public NuGenDocument(SerializationInfo info, StreamingContext ctxt)
        {
            backgroundSelection = (BackgroundSelection)info.GetValue("backgroundSelection", typeof(BackgroundSelection));
            originalImage       = (Image)info.GetValue("originalImage", typeof(Image));

            title = (string)info.GetValue("title", typeof(string));

            digitizeState = (DigitizeState)info.GetValue("digitizeState", typeof(DigitizeState));

            currentCurveName   = (string)info.GetValue("curveCmbText", typeof(string));
            currentMeasureName = (string)info.GetValue("measureCmbText", typeof(string));

            coordSettings.frame       = (ReferenceFrame)info.GetValue("coordSettings.frame", typeof(ReferenceFrame));
            coordSettings.thetaUnits  = (ThetaUnits)info.GetValue("coordSettings.thetaUnits", typeof(ThetaUnits));
            coordSettings.xThetaScale = (Scale)info.GetValue("coordSettings.xThetaScale", typeof(Scale));
            coordSettings.yRScale     = (Scale)info.GetValue("coordSettings.yRScale", typeof(Scale));

            exportSettings.delimiters      = (ExportDelimiters)info.GetValue("exportSettings.delimiters", typeof(ExportDelimiters));
            exportSettings.layout          = (ExportLayout)info.GetValue("exportSettings.layout", typeof(ExportLayout));
            exportSettings.pointsSelection = (ExportPointsSelection)info.GetValue("exportSettings.pointsSelection", typeof(ExportPointsSelection));
            exportSettings.header          = (ExportHeader)info.GetValue("exportSettings.header", typeof(ExportHeader));

            gridRemovalSettings.removeThinLines      = (bool)info.GetValue("gridRemovalSettings.removeThinLines", typeof(bool));
            gridRemovalSettings.thinThickness        = (double)info.GetValue("gridRemovalSettings.thinThickness", typeof(double));
            gridRemovalSettings.removeGridlines      = (bool)info.GetValue("gridRemovalSettings.removeGridlines", typeof(bool));
            gridRemovalSettings.gridMesh.initialized = (bool)info.GetValue("gridRemovalSettings.gridMesh.initialized", typeof(bool));
            gridRemovalSettings.gridMesh.countX      = (int)info.GetValue("gridRemovalSettings.gridMesh.countX", typeof(int));
            gridRemovalSettings.gridMesh.countY      = (int)info.GetValue("gridRemovalSettings.gridMesh.countY", typeof(int));
            gridRemovalSettings.gridMesh.gridSetX    = (GridSet)info.GetValue("gridRemovalSettings.gridMesh.gridSetX", typeof(GridSet));
            gridRemovalSettings.gridMesh.gridSetY    = (GridSet)info.GetValue("gridRemovalSettings.gridMesh.gridSetY", typeof(GridSet));
            gridRemovalSettings.gridMesh.startX      = (double)info.GetValue("gridRemovalSettings.gridMesh.startX", typeof(double));
            gridRemovalSettings.gridMesh.startY      = (double)info.GetValue("gridRemovalSettings.gridMesh.startY", typeof(double));
            gridRemovalSettings.gridMesh.stepX       = (double)info.GetValue("gridRemovalSettings.gridMesh.stepX", typeof(double));
            gridRemovalSettings.gridMesh.stepY       = (double)info.GetValue("gridRemovalSettings.gridMesh.stepY", typeof(double));
            gridRemovalSettings.gridMesh.stopX       = (double)info.GetValue("gridRemovalSettings.gridMesh.stopX", typeof(double));
            gridRemovalSettings.gridMesh.stopY       = (double)info.GetValue("gridRemovalSettings.gridMesh.stopY", typeof(double));
            gridRemovalSettings.gridDistance         = (double)info.GetValue("gridRemovalSettings.gridDistance", typeof(double));
            gridRemovalSettings.removeColor          = (bool)info.GetValue("gridRemovalSettings.removeColor", typeof(bool));
            gridRemovalSettings.color = (Color)info.GetValue("gridRemovalSettings.color", typeof(Color));
            gridRemovalSettings.foregroundThresholdLow  = (int)info.GetValue("gridRemovalSettings.foregroundThresholdLow", typeof(int));
            gridRemovalSettings.foregroundThresholdHigh = (int)info.GetValue("gridRemovalSettings.foregroundThresholdHigh", typeof(int));
            gridRemovalSettings.gapSeparation           = (double)info.GetValue("gridRemovalSettings.gapSeparation", typeof(double));

            gridDisplaySettings.initialized = (bool)info.GetValue("gridDisplaySettings.initialized", typeof(bool));
            gridDisplaySettings.countX      = (int)info.GetValue("gridDisplaySettings.countX", typeof(int));
            gridDisplaySettings.countY      = (int)info.GetValue("gridDisplaySettings.countY", typeof(int));
            gridDisplaySettings.gridSetX    = (GridSet)info.GetValue("gridDisplaySettings.gridSetX", typeof(GridSet));
            gridDisplaySettings.gridSetY    = (GridSet)info.GetValue("gridDisplaySettings.gridSetY", typeof(GridSet));
            gridDisplaySettings.startX      = (double)info.GetValue("gridDisplaySettings.startX", typeof(double));
            gridDisplaySettings.startY      = (double)info.GetValue("gridDisplaySettings.startY", typeof(double));
            gridDisplaySettings.stepX       = (double)info.GetValue("gridDisplaySettings.stepX", typeof(double));
            gridDisplaySettings.stepY       = (double)info.GetValue("gridDisplaySettings.stepY", typeof(double));
            gridDisplaySettings.stopX       = (double)info.GetValue("gridDisplaySettings.stopX", typeof(double));
            gridDisplaySettings.stopY       = (double)info.GetValue("gridDisplaySettings.stopY", typeof(double));

            segmentSettings.minPoints       = (int)info.GetValue("segmentSettings.minPoints", typeof(int));
            segmentSettings.pointSeparation = (int)info.GetValue("segmentSettings.pointSeparation", typeof(int));
            segmentSettings.lineSize        = (LineSize)info.GetValue("segmentSettings.lineSize", typeof(LineSize));
            segmentSettings.lineColor       = (Color)info.GetValue("segmentSettings.lineColor", typeof(Color));

            pointMatchSettings.pointSeparation = (int)info.GetValue("pointMatchSettings.pointSeparation", typeof(int));
            pointMatchSettings.pointSize       = (int)info.GetValue("pointMatchSettings.pointSize", typeof(int));
            pointMatchSettings.acceptedColor   = (Color)info.GetValue("pointMatchSettings.acceptedColor", typeof(Color));
            pointMatchSettings.rejectedColor   = (Color)info.GetValue("pointMatchSettings.rejectedColor", typeof(Color));

            discretizeSettings.discretizeMethod        = (DiscretizeMethod)info.GetValue("discretizeSettings.discretizeMethod", typeof(DiscretizeMethod));
            discretizeSettings.intensityThresholdLow   = (int)info.GetValue("discretizeSettings.intensityThresholdLow", typeof(int));
            discretizeSettings.intensityThresholdHigh  = (int)info.GetValue("discretizeSettings.intensityThresholdHigh", typeof(int));
            discretizeSettings.foregroundThresholdLow  = (int)info.GetValue("discretizeSettings.foregroundThresholdLow", typeof(int));
            discretizeSettings.foregroundThresholdHigh = (int)info.GetValue("discretizeSettings.foregroundThresholdHigh", typeof(int));
            discretizeSettings.hueThresholdLow         = (int)info.GetValue("discretizeSettings.hueThresholdLow", typeof(int));
            discretizeSettings.hueThresholdHigh        = (int)info.GetValue("discretizeSettings.hueThresholdHigh", typeof(int));
            discretizeSettings.saturationThresholdLow  = (int)info.GetValue("discretizeSettings.saturationThresholdLow", typeof(int));
            discretizeSettings.saturationThresholdHigh = (int)info.GetValue("discretizeSettings.saturationThresholdHigh", typeof(int));
            discretizeSettings.valueThresholdLow       = (int)info.GetValue("discretizeSettings.valueThresholdLow", typeof(int));
            discretizeSettings.valueThresholdHigh      = (int)info.GetValue("discretizeSettings.valueThresholdHigh", typeof(int));

            pointSets = new NuGenPointSetCollection();

            PointSets.SerializeRead(info);

            saveFileExists           = true;
            dirtyAxesTransformation  = true;
            dirtyScaleTransformation = true;

            listeners = new List <NuGenImageListener>();

            segments    = new NuGenSegmentCollection();
            transform   = new NuGenScreenTranslate(this);
            gridDisplay = new List <GridlineScreen>();
            matchSet    = new NuGenMatchSet(pointMatchSettings);

            ProcessOriginialImage();
        }
Пример #29
0
        //Removes thin lines which are parallel to the user defined axes
        private void RemoveThinLines(PixelState[,] pixels, CoordSettings coordSettings, NuGenScreenTranslate transform,
                                     double thinThickness, PixelState pixelStateRemovedPass1, PixelState pixelStateRemovedPass2)
        {
            if (transform.ValidAxes)
            {
                InitializeThin(coordSettings, transform, thinThickness);

                // first pass erases the gridMeshSettings lines, except for the junctions
                EraseThinPixels(pixels, thinThickness, pixelStateRemovedPass1);

                // second pass erases the gridMeshSettings line junctions, which are little islands of on-pixels
                EraseThinPixels(pixels, thinThickness, pixelStateRemovedPass2);
            }
        }