} // Main(...) static ICollection<CheetahCurve> EvaluationOnTheFirstApplicationOfConstraint(ICheetahSolver solver, CheetahDataSet dataSet) { // 1. Creating parametric object and setting tolerance (by default 1E-12) var parametric = new CheetahParametricBasic(() => solver, false, true, true); // 2. Initializing parametric object using data set // On this step we are compiling the model and creating system of equation // After that we will be ready to run the solver if (!parametric.Init(dataSet, null, null)) // If parametric.Init will return FALSE, then there is critical error in the data set // So we are not able to make system of equation and to evaluate the problem // We should cancel the procedure and rebuild data set throw new Exception("Something goes wrong"); // 3. Regenerating constrained model (running solver) // On this step we are solving the system of equation, that we've made in the previous step if (!parametric.Evaluate()) throw new Exception("Something goes wrong"); // 4. Retrieving results var resultGeometry = parametric.GetSolution(true); // 5. We have to clear compiled data parametric.ClearSolver(); return resultGeometry; } // EvaluationOnTheFirstApplicationOfConstraint(...)
} // Main(...) static ICollection <CheetahCurve> EvaluationOnTheFirstApplicationOfConstraint(ICheetahSolver solver, CheetahDataSet dataSet) { // 1. Creating parametric object and setting tolerance (by default 1E-12) var parametric = new CheetahParametricBasic(() => solver, false, true, true); // 2. Initializing parametric object using data set // On this step we are compiling the model and creating system of equation // After that we will be ready to run the solver if (!parametric.Init(dataSet, null, null)) { // If parametric.Init will return FALSE, then there is critical error in the data set // So we are not able to make system of equation and to evaluate the problem // We should cancel the procedure and rebuild data set throw new Exception("Something goes wrong"); } // 3. Regenerating constrained model (running solver) // On this step we are solving the system of equation, that we've made in the previous step if (!parametric.Evaluate()) { throw new Exception("Something goes wrong"); } // 4. Retrieving results var resultGeometry = parametric.GetSolution(true); // 5. We have to clear compiled data parametric.ClearSolver(); return(resultGeometry); } // EvaluationOnTheFirstApplicationOfConstraint(...)
static void Main(string[] args) { // 1. Creating geometric model var dataSet = new CheetahDataSet(); var entIdList = new List <long>(); CreateGeometricModel(dataSet, entIdList); // 2. Creating solver object var solver = new SolverCpu10(); // 3. Creating parametric object and setting tolerance (by default 1E-12) var parametric = new CheetahParametricBasic(() => solver, false); const double precision = 1E-15; // Working with much better accuracy then the default 1E-12 CheetahParametricBasic.Settings.Precision = precision; // 4. Initializing parametric object using data set if (!parametric.Init(dataSet, null, null)) { throw new Exception("Something goes wrong"); } // 5. Running constraints solver if (!parametric.Evaluate()) { throw new Exception("Something goes wrong"); } // 6. Retrieving results (we created rectangle with fillets that is "closest" to the initial lines and arcs) var resultGeometry = parametric.GetSolution(true); // 7. Checking that all geometric constraints are satisfied. // Actually, we have no need to check - if Evaluate returns true than everything is OK if (!CheckResults(resultGeometry, entIdList, precision)) { throw new Exception("Something goes wrong"); } GC.Collect(); } // Main(...)
static void Main(string[] args) { const string filePath = "dataset.xml"; // 1. Creating entities and constraints (constraints are not satisfied yet) var dataSet = CreateDataSet(); // 2. Saving data set to xml-file dataSet.SaveToXml(filePath); // 3. Loading data set from xml-file var dataSetFromFile = CheetahDataSet.LoadFromXml(filePath); // 4. Creating solver object var solver = new SolverCpu10(); // 5. Creating parametric object and setting tolerance (by default 1E-12) var parametric = new CheetahParametricBasic(() => solver, false, true, true); const double precision = 1E-8; // Working with lower accuracy then default 1E-12 CheetahParametricBasic.Settings.Precision = precision; // 6. Initializing parametric object using data set if (!parametric.Init(dataSetFromFile, null, null)) { throw new Exception("Something goes wrong"); } // 7. Regenerating constrained model (running solver) if (!parametric.Evaluate()) { throw new Exception("Something goes wrong"); } // 8. Retrieving results (we created rectangle that is "closest" to the initial lines) var resultGeometry = parametric.GetSolution(true); GC.Collect(); } // Main(...)
static void Main(string[] args) { // 1. Creating geometric model var dataSet = new CheetahDataSet(); var entIdList = new List<long>(); CreateGeometricModel(dataSet, entIdList); // 2. Creating solver object var solver = new SolverCpu10(); // 3. Creating parametric object and setting tolerance (by default 1E-12) var parametric = new CheetahParametricBasic(() => solver, false); const double precision = 1E-15; // Working with much better accuracy then the default 1E-12 CheetahParametricBasic.Settings.Precision = precision; // 4. Initializing parametric object using data set if (!parametric.Init(dataSet, null, null)) throw new Exception("Something goes wrong"); // 5. Running constraints solver if (!parametric.Evaluate()) throw new Exception("Something goes wrong"); // 6. Retrieving results (we created rectangle with fillets that is "closest" to the initial lines and arcs) var resultGeometry = parametric.GetSolution(true); // 7. Checking that all geometric constraints are satisfied. // Actually, we have no need to check - if Evaluate returns true than everything is OK if (!CheckResults(resultGeometry, entIdList, precision)) throw new Exception("Something goes wrong"); GC.Collect(); } // Main(...)
static void Main(string[] args) { const string filePath = "dataset.xml"; // 1. Creating entities and constraints (constraints are not satisfied yet) var dataSet = CreateDataSet(); // 2. Saving data set to xml-file dataSet.SaveToXml(filePath); // 3. Loading data set from xml-file var dataSetFromFile = CheetahDataSet.LoadFromXml(filePath); // 4. Creating solver object var solver = new SolverCpu10(); // 5. Creating parametric object and setting tolerance (by default 1E-12) var parametric = new CheetahParametricBasic(() => solver, false, true, true); const double precision = 1E-8; // Working with lower accuracy then default 1E-12 CheetahParametricBasic.Settings.Precision = precision; // 6. Initializing parametric object using data set if (!parametric.Init(dataSetFromFile, null, null)) throw new Exception("Something goes wrong"); // 7. Regenerating constrained model (running solver) if (!parametric.Evaluate()) throw new Exception("Something goes wrong"); // 8. Retrieving results (we created rectangle that is "closest" to the initial lines) var resultGeometry = parametric.GetSolution(true); GC.Collect(); } // Main(...)
} // EvaluationOnTheFirstApplicationOfConstraint(...) static ICollection<CheetahCurve> EvaluationOnDragginTheLine(ICheetahSolver solver, CheetahDataSet dataSet, CheetahLine2D draggingLine, CheetahPoint2D draggingPoint) { // 1. Creating parametric object and setting tolerance (by default 1E-12) var parametric = new CheetahParametricBasic(() => solver, false, true, true); // 2. Initializing parametric object using data set // On this step we are compiling the model and creating system of equation // After that we will be ready to run the solver // We will drag the line, so we need to specify the curve to drag and the dragging point if (!parametric.Init(dataSet, new[] { draggingLine }, new[] { draggingPoint })) // If parametric.Init will return FALSE, then there is critical error in data set // So we are not able to make system of equation and to evaluate the problem // We should cancel the procedure and rebuild data set throw new Exception("Something goes wrong"); // 3. Now we can drag. We don't need to recompile the model on each drag iteration, // because the model will be the same - only initial value (the drag point) will be changed // We are simulating drag using this loop for (var i = 0; i < 100; i++) { // 4. Our parametric object is initialized by dataSet object // So the current values of the dataSet curves are the initial values of the system // If we will change some value - the initial values will be changed appropriately // All that we need to reinitialize the model by the new point from the screen // is to reset the value for the dragging line end point draggingLine.End.X *= 1.01; draggingLine.End.Y *= 1.05; // 5. Regenerating constrained model (running solver) // On this step we are solving the system of equation, that we've prepared on the previous step // Now we are dragging the curve and, because we do it manually (by mouse), we can not be precise // We don't need to calculate on each step with 10^-12 or greater precision // So we can cheat a little and decrease the precision for drag iterations // That's why we are using parametric.EvaluateFast function if (!parametric.EvaluateFast()) // If parametric.EvaluateFast will return FALSE it usually means that we can not evaluate the system // with this initial values (we have reached maximum number of iterations)/ // It is NOT a critical problem. This situation can appear while we drag some curve // in position that conflict with constraints/ // For example, while we rounding out the arc and can get negative radius, // or squeeze the line to zero length (and get negative length) // In our solver, if we have such a situation - we restore the previous drag iteration solution. throw new Exception("Something goes wrong"); // In this example we don't use results of EvaluateFast/ // In real life they may be retreived and used to update dragging lines on the screen } // 6. Regenerating constrained model (running solver) // Now we "click the mouse button" to end the drag. // We need to evaluate the system with high precision (that's why we use Evaluate instead of EvaluateFast) // We can use last iteration solution as new initial value to evaluate the system much faster // (for this purpose we set recompile parameter to false) if (!parametric.Evaluate(false)) throw new Exception("Something goes wrong"); // 7. Retrieving results var resultGeometry = parametric.GetSolution(true); // 8. We have to clear compiled data parametric.ClearSolver(); return resultGeometry; } // EvaluationOnDragginTheLine(...)
} // EvaluationOnTheFirstApplicationOfConstraint(...) static ICollection <CheetahCurve> EvaluationOnDragginTheLine(ICheetahSolver solver, CheetahDataSet dataSet, CheetahLine2D draggingLine, CheetahPoint2D draggingPoint) { // 1. Creating parametric object and setting tolerance (by default 1E-12) var parametric = new CheetahParametricBasic(() => solver, false, true, true); // 2. Initializing parametric object using data set // On this step we are compiling the model and creating system of equation // After that we will be ready to run the solver // We will drag the line, so we need to specify the curve to drag and the dragging point if (!parametric.Init(dataSet, new[] { draggingLine }, new[] { draggingPoint })) { // If parametric.Init will return FALSE, then there is critical error in data set // So we are not able to make system of equation and to evaluate the problem // We should cancel the procedure and rebuild data set throw new Exception("Something goes wrong"); } // 3. Now we can drag. We don't need to recompile the model on each drag iteration, // because the model will be the same - only initial value (the drag point) will be changed // We are simulating drag using this loop for (var i = 0; i < 100; i++) { // 4. Our parametric object is initialized by dataSet object // So the current values of the dataSet curves are the initial values of the system // If we will change some value - the initial values will be changed appropriately // All that we need to reinitialize the model by the new point from the screen // is to reset the value for the dragging line end point draggingLine.End.X *= 1.01; draggingLine.End.Y *= 1.05; // 5. Regenerating constrained model (running solver) // On this step we are solving the system of equation, that we've prepared on the previous step // Now we are dragging the curve and, because we do it manually (by mouse), we can not be precise // We don't need to calculate on each step with 10^-12 or greater precision // So we can cheat a little and decrease the precision for drag iterations // That's why we are using parametric.EvaluateFast function if (!parametric.EvaluateFast()) { // If parametric.EvaluateFast will return FALSE it usually means that we can not evaluate the system // with this initial values (we have reached maximum number of iterations)/ // It is NOT a critical problem. This situation can appear while we drag some curve // in position that conflict with constraints/ // For example, while we rounding out the arc and can get negative radius, // or squeeze the line to zero length (and get negative length) // In our solver, if we have such a situation - we restore the previous drag iteration solution. throw new Exception("Something goes wrong"); } // In this example we don't use results of EvaluateFast/ // In real life they may be retreived and used to update dragging lines on the screen } // 6. Regenerating constrained model (running solver) // Now we "click the mouse button" to end the drag. // We need to evaluate the system with high precision (that's why we use Evaluate instead of EvaluateFast) // We can use last iteration solution as new initial value to evaluate the system much faster // (for this purpose we set recompile parameter to false) if (!parametric.Evaluate(false)) { throw new Exception("Something goes wrong"); } // 7. Retrieving results var resultGeometry = parametric.GetSolution(true); // 8. We have to clear compiled data parametric.ClearSolver(); return(resultGeometry); } // EvaluationOnDragginTheLine(...)
static void Main(string[] args) { // 1. Creating data set var dataSet = new CheetahDataSet(); // 2. Creating geometry var line1 = new CheetahLine2D(0, 0, 10, 1); var line2 = new CheetahLine2D(10, 0, 10, 11); var line3 = new CheetahLine2D(10, 10, 1, 10); var line4 = new CheetahLine2D(0, 10, 1, 1); // 3. Creating constraints dataSet.AddCoincidence(line1, IdentifiableValueReferences.LineEnd, line2, IdentifiableValueReferences.LineStart); dataSet.AddCoincidence(line2, IdentifiableValueReferences.LineEnd, line3, IdentifiableValueReferences.LineStart); dataSet.AddCoincidence(line3, IdentifiableValueReferences.LineEnd, line4, IdentifiableValueReferences.LineStart); dataSet.AddCoincidence(line4, IdentifiableValueReferences.LineEnd, line1, IdentifiableValueReferences.LineStart); dataSet.AddPerpendicular(line1, line2); dataSet.AddPerpendicular(line2, line3); dataSet.AddParallel(line2, line4); // 4. Creating solver object var solver = new SolverCpu10(); // 5. Creating parametric object and setting tolerance (by default 1E-12) var parametric = new CheetahParametricBasic(() => solver, false, true, true); const double precision = 1E-14; // Working with better accuracy then default 1E-12 CheetahParametricBasic.Settings.Precision = precision; // 6. Initializing parametric object using data set if (!parametric.Init(dataSet, null, null)) { throw new Exception("Something goes wrong"); } // 7. Regenerating constrained model (running solver) if (!parametric.Evaluate()) { throw new Exception("Something goes wrong"); } // 8. Retrieving results (we created rectangle that is "closest" to the initial lines) var resultGeometry = parametric.GetSolution(true); // 9. We can find corresponding objects by id var resultLine1 = (CheetahLine2D)resultGeometry.Single(x => x.Id == line1.Id); var resultLine2 = (CheetahLine2D)resultGeometry.Single(x => x.Id == line2.Id); var resultLine3 = (CheetahLine2D)resultGeometry.Single(x => x.Id == line3.Id); var resultLine4 = (CheetahLine2D)resultGeometry.Single(x => x.Id == line4.Id); // 10. Now we can check that all constraints are satisfied (line segments form rectangle) if (Math.Abs(resultLine1.End.X - resultLine2.Start.X) > precision || Math.Abs(resultLine1.End.Y - resultLine2.Start.Y) > precision) { throw new Exception("Something goes wrong"); } if (Math.Abs(resultLine2.End.X - resultLine3.Start.X) > precision || Math.Abs(resultLine2.End.Y - resultLine3.Start.Y) > precision) { throw new Exception("Something goes wrong"); } if (Math.Abs(resultLine3.End.X - resultLine4.Start.X) > precision || Math.Abs(resultLine3.End.Y - resultLine4.Start.Y) > precision) { throw new Exception("Something goes wrong"); } if (Math.Abs(resultLine4.End.X - resultLine1.Start.X) > precision || Math.Abs(resultLine4.End.Y - resultLine1.Start.Y) > precision) { throw new Exception("Something goes wrong"); } if (!IsDivisible(resultLine1.PolarAngle - resultLine2.PolarAngle, Math.PI / 2, precision)) { throw new Exception("Something goes wrong"); } if (!IsDivisible(resultLine2.PolarAngle - resultLine3.PolarAngle, Math.PI / 2, precision)) { throw new Exception("Something goes wrong"); } if (!IsDivisible(resultLine2.PolarAngle - resultLine4.PolarAngle, Math.PI, precision)) { throw new Exception("Something goes wrong"); } GC.Collect(); } // Main(...)
static void Main(string[] args) { // 1. Creating data set var dataSet = new CheetahDataSet(); // 2. Creating geometry var line1 = new CheetahLine2D(0, 0, 10, 1); var line2 = new CheetahLine2D(10, 0, 10, 11); var line3 = new CheetahLine2D(10, 10, 1, 10); var line4 = new CheetahLine2D(0, 10, 1, 1); // 3. Creating constraints dataSet.AddCoincidence(line1, IdentifiableValueReferences.LineEnd, line2, IdentifiableValueReferences.LineStart); dataSet.AddCoincidence(line2, IdentifiableValueReferences.LineEnd, line3, IdentifiableValueReferences.LineStart); dataSet.AddCoincidence(line3, IdentifiableValueReferences.LineEnd, line4, IdentifiableValueReferences.LineStart); dataSet.AddCoincidence(line4, IdentifiableValueReferences.LineEnd, line1, IdentifiableValueReferences.LineStart); dataSet.AddPerpendicular(line1, line2); dataSet.AddPerpendicular(line2, line3); dataSet.AddParallel(line2, line4); // 4. Creating solver object var solver = new SolverCpu10(); // 5. Creating parametric object and setting tolerance (by default 1E-12) var parametric = new CheetahParametricBasic(() => solver, false, true, true); const double precision = 1E-14; // Working with better accuracy then default 1E-12 CheetahParametricBasic.Settings.Precision = precision; // 6. Initializing parametric object using data set if (!parametric.Init(dataSet, null, null)) throw new Exception("Something goes wrong"); // 7. Regenerating constrained model (running solver) if (!parametric.Evaluate()) throw new Exception("Something goes wrong"); // 8. Retrieving results (we created rectangle that is "closest" to the initial lines) var resultGeometry = parametric.GetSolution(true); // 9. We can find corresponding objects by id var resultLine1 = (CheetahLine2D)resultGeometry.Single(x => x.Id == line1.Id); var resultLine2 = (CheetahLine2D)resultGeometry.Single(x => x.Id == line2.Id); var resultLine3 = (CheetahLine2D)resultGeometry.Single(x => x.Id == line3.Id); var resultLine4 = (CheetahLine2D)resultGeometry.Single(x => x.Id == line4.Id); // 10. Now we can check that all constraints are satisfied (line segments form rectangle) if (Math.Abs(resultLine1.End.X - resultLine2.Start.X) > precision || Math.Abs(resultLine1.End.Y - resultLine2.Start.Y) > precision) throw new Exception("Something goes wrong"); if (Math.Abs(resultLine2.End.X - resultLine3.Start.X) > precision || Math.Abs(resultLine2.End.Y - resultLine3.Start.Y) > precision) throw new Exception("Something goes wrong"); if (Math.Abs(resultLine3.End.X - resultLine4.Start.X) > precision || Math.Abs(resultLine3.End.Y - resultLine4.Start.Y) > precision) throw new Exception("Something goes wrong"); if (Math.Abs(resultLine4.End.X - resultLine1.Start.X) > precision || Math.Abs(resultLine4.End.Y - resultLine1.Start.Y) > precision) throw new Exception("Something goes wrong"); if (!IsDivisible(resultLine1.PolarAngle - resultLine2.PolarAngle, Math.PI / 2, precision)) throw new Exception("Something goes wrong"); if (!IsDivisible(resultLine2.PolarAngle - resultLine3.PolarAngle, Math.PI / 2, precision)) throw new Exception("Something goes wrong"); if (!IsDivisible(resultLine2.PolarAngle - resultLine4.PolarAngle, Math.PI, precision)) throw new Exception("Something goes wrong"); GC.Collect(); } // Main(...)