public static bool ComputePositionDefault(IEntityContainer factory, Box2D boxBorder, Vector2D spaceBetween, ref List <BPosition> lPos, ref Box2D bbox) { if (boxBorder.Width <= 0.0 || boxBorder.Height <= 0.0) { return(false); } ImpositionTool tool = Instantiate(factory, new ImpositionSettings(boxBorder.Width, boxBorder.Height)); tool.SpaceBetween = spaceBetween; tool.AllowOrthogonalImposition = true; tool.AllowBothDirection = false; tool.HorizontalAlignment = ImpositionSettings.HAlignment.HALIGN_LEFT; tool.VerticalAlignment = ImpositionSettings.VAlignment.VALIGN_BOTTOM; tool.GenerateSortedSolutionList(null, out List <ImpositionSolution> solutions); if (solutions.Count > 0) { ImpositionSolution impSol = solutions[0]; Vector2D cardboardPos = impSol.CardboardPosition; foreach (var p in impSol.Positions) { BPosition pos = p; pos.Pt += boxBorder.PtMin - cardboardPos; lPos.Add(pos); } Vector2D ptMin = impSol.Bbox.PtMin + boxBorder.PtMin; Vector2D ptMax = impSol.Bbox.PtMax + boxBorder.PtMin; bbox = new Box2D(ptMin, ptMax); } return(lPos.Count > 0); }
/* * internal ImpositionPattern GeneratePattern(int id, Vector2D minDistance, Vector2D impositionOffset, bool orthoImp) * { * ImpositionPattern pattern = null; * * KeyValuePair<int, bool> kvpIndexOrtho = new KeyValuePair<int, bool>(id, orthoImp); * switch (id) * { * case 0: pattern = new PatternDefault(); break; * case 1: pattern = new PatternRotationInRow(); break; * case 2: pattern = new PatternRotationInColumn(); break; * } * return pattern; * } */ #endregion #region Public methods public bool GenerateEntities(string patternName, bool orthogonalImposition, ref PicFactory factory) { ImpositionPattern pattern = GetPatternByName(patternName); pattern.GeneratePattern(InitialEntities, SpaceBetween, ImpositionOffset, orthogonalImposition); ImpositionSolution solution = GenerateSolution(pattern, orthogonalImposition); solution.CreateEntities(factory); return(true); }
public bool GenerateSortedSolutionList(IProgressCallback callback, out List <ImpositionSolution> solutions) { // get applicable pattern list List <ImpositionPattern> patternList = GetPatternList(); // need to compute orthogonal positions ? bool processOrthogonalImposition = AllowOrthogonalImposition; /*_allowOrthogonalImposition && (_cardboardFormat.Width != _cardboardFormat.Height);*/ // compute number of expected solutions if (null != callback) { callback.Begin(0, patternList.Count * (processOrthogonalImposition ? 4 : 2)); } // instantiate solution list solutions = new List <ImpositionSolution>(); // process pattern list foreach (ImpositionPattern pattern in patternList) { // generate pattern try { pattern.GeneratePattern(InitialEntities, SpaceBetween, ImpositionOffset, false); } catch (Exception ex) { _log.Error(ex.Message); continue; } // default orientation ImpositionSolution solution = GenerateSolution(pattern); if (null != solution && solution.IsValid) { solution.UnitLengthCut = _unitLengthCut; solution.UnitLengthFold = _unitLengthFold; solution.UnitArea = _unitArea; solutions.Add(solution); } // increment progress dialog? if (null != callback) { callback.Increment(solutions.Count); } // orthogonal direction if (processOrthogonalImposition) { // generate pattern try { pattern.GeneratePattern(InitialEntities, SpaceBetween, ImpositionOffset, true); } catch (Exception ex) { _log.Error(ex.Message); continue; } solution = GenerateSolution(pattern); if (null != solution && solution.IsValid) { solution.UnitLengthCut = _unitLengthCut; solution.UnitLengthFold = _unitLengthFold; solution.UnitArea = _unitArea; solutions.Add(solution); } } // increment progress dialog? if (null != callback) { callback.Increment(solutions.Count); } } // generate thumbnails foreach (ImpositionSolution sol in solutions) { sol.GenerateThumbnail(); // increment progress dialog? if (null != callback) { callback.Increment(solutions.Count); } } // sort solution list solutions.Sort(new SolutionComparerFormat()); if (null != callback) { callback.End(); } return(solutions.Count > 0); }
internal override ImpositionSolution GenerateSolution(ImpositionPattern pattern) { // instantiate solution ImpositionSolution solution = new ImpositionSolution(InitialEntities, pattern.Name, pattern.RequiresRotationInRows, pattern.RequiresRotationInColumns); // noRows / noCols solution.Rows = NoRowsExpected; solution.Cols = NoColsExpected; // number of each row / col of the pattern int[,] rowNumber = new int[pattern.NoRows, pattern.NoCols]; int[,] colNumber = new int[pattern.NoRows, pattern.NoCols]; int iCount = 0; for (int i = 0; i < pattern.NoRows; ++i) { for (int j = 0; j < pattern.NoCols; ++j) { colNumber[i, j] = NoRowsExpected / pattern.NoRows + (NoRowsExpected % pattern.NoRows) / (i + 1); rowNumber[i, j] = NoColsExpected / pattern.NoCols + (NoColsExpected % pattern.NoCols) / (j + 1); iCount += rowNumber[i, j] * colNumber[i, j]; } } // verify count System.Diagnostics.Debug.Assert(iCount == NoRowsExpected * NoColsExpected); // compute offsets Box2D boxGlobal = pattern.BBox; double xOffset = _margin.X - boxGlobal.XMin; double yOffset = _margin.Y - boxGlobal.YMin; _box = new Box2D(); for (int i = 0; i < pattern.NoRows; ++i) { for (int j = 0; j < pattern.NoCols; ++j) { Box2D localBox = pattern._bboxes[i, j]; for (int k = 0; k < rowNumber[i, j]; ++k) { for (int l = 0; l < colNumber[i, j]; ++l) { // insert Box position BPosition pos = pattern._relativePositions[i, j]; pos._pt.X = xOffset + k * pattern.PatternStep.X + pos._pt.X; pos._pt.Y = yOffset + l * pattern.PatternStep.Y + pos._pt.Y; solution.Add(pos); // extend bounding box Vector2D vOffset = new Vector2D(xOffset + k * pattern.PatternStep.X, yOffset + l * pattern.PatternStep.Y); _box.Extend(new Box2D(vOffset + localBox.PtMin, vOffset + localBox.PtMax)); } } } } // compute actual margin solution.CardboardPosition = new Vector2D(_margin.X, _margin.Y); solution.CardboardDimensions = new Vector2D(_box.XMax - _box.XMin + _margin.X + _minMargin.X, _box.YMax - _box.YMin + _margin.Y + _minMargin.Y); return(solution); }
internal override ImpositionSolution GenerateSolution(ImpositionPattern pattern, bool orthoImp) { // instantiate solution ImpositionSolution solution = new ImpositionSolution(InitialEntities, pattern.Name, orthoImp, pattern.RequiresRotationInRows, pattern.RequiresRotationInColumns); // pattern box Box2D boxPattern = pattern.BBox; // compute max number of patterns int noPatternX = NoPatternX(pattern); int noPatternY = NoPatternY(pattern); int[,] rowNumber = new int[pattern.NoRows, pattern.NoCols]; int[,] colNumber = new int[pattern.NoRows, pattern.NoCols]; int iMax = -1, jMax = -1; for (int i = 0; i < pattern.NoRows; ++i) { for (int j = 0; j < pattern.NoCols; ++j) { if (pattern._bboxes[i, j].XMax + noPatternX * pattern.PatternStep.X - boxPattern.XMin < UsableFormat.Width) { rowNumber[i, j] = noPatternX + 1; iMax = i; } else { rowNumber[i, j] = noPatternX; } if (pattern._bboxes[i, j].YMax + noPatternY * pattern.PatternStep.Y - boxPattern.YMin < UsableFormat.Height) { colNumber[i, j] = noPatternY + 1; jMax = j; } else { colNumber[i, j] = noPatternY; } } } // compute actual margin Box2D boxGen = Box2D.Initial; for (int i = 0; i < pattern.NoRows; ++i) { for (int j = 0; j < pattern.NoCols; ++j) { for (int k = 0; k < rowNumber[i, j]; ++k) { for (int l = 0; l < colNumber[i, j]; ++l) { Vector2D vPatternStep = new Vector2D(k * pattern.PatternStep.X, l * pattern.PatternStep.Y); boxGen.Extend(pattern._bboxes[i, j].PtMin + vPatternStep); boxGen.Extend(pattern._bboxes[i, j].PtMax + vPatternStep); } } } } if (!boxGen.IsValid) { return(solution); } #region Additional both direction // **** // get remaining space in length and width double remainingX = UsableFormat.Width - boxGen.Width - SpaceBetween.X; double remainingY = UsableFormat.Height - boxGen.Height - SpaceBetween.Y; // here compute additionnal poses on right Box2D bboxRight = Box2D.Initial; List <BPosition> lPosRight = new List <BPosition>(); if (AllowBothDirection) { Vector2D vLowerLeft = new Vector2D(boxGen.PtMax.X, boxGen.PtMin.Y); Vector2D vTopRight = vLowerLeft + new Vector2D(remainingX, UsableFormat.Height); if (ComputePositionDefault(InitialEntities, new Box2D(vLowerLeft, vTopRight), SpaceBetween, ref lPosRight, ref bboxRight)) { boxGen.Extend(bboxRight); } } // here compute additionnal poses on top Box2D bboxTop = Box2D.Initial; List <BPosition> lPosTop = new List <BPosition>(); if (AllowBothDirection) { Vector2D vLowerLeft = new Vector2D(boxGen.PtMin.X, boxGen.PtMax.Y); Vector2D vTopRight = vLowerLeft + new Vector2D(UsableFormat.Width, remainingY); if (ComputePositionDefault(InitialEntities, new Box2D(vLowerLeft, vTopRight), SpaceBetween, ref lPosTop, ref bboxTop)) { boxGen.Extend(bboxTop); } } // **** #endregion double xMargin = 0.0; switch (HorizontalAlignment) { case ImpositionSettings.HAlignment.HALIGN_LEFT: xMargin = UsableFormat.XMin; break; case ImpositionSettings.HAlignment.HALIGN_RIGHT: xMargin = FormatDimensions.X - Margin.X - boxGen.Width; break; case ImpositionSettings.HAlignment.HALIGN_CENTER: xMargin = (FormatDimensions.X - boxGen.Width) * 0.5; break; default: break; } double yMargin = 0.0; switch (VerticalAlignment) { case ImpositionSettings.VAlignment.VALIGN_BOTTOM: yMargin = UsableFormat.YMin; break; case ImpositionSettings.VAlignment.VALIGN_TOP: yMargin = FormatDimensions.Y - Margin.Y - boxGen.Height; break; case ImpositionSettings.VAlignment.VALIGN_CENTER: yMargin = (FormatDimensions.Y - boxGen.Height) * 0.5; break; default: break; } // compute offsets Vector2D vOffset = new Vector2D(xMargin - boxPattern.XMin, yMargin - boxPattern.YMin); for (int i = 0; i < pattern.NoRows; ++i) { for (int j = 0; j < pattern.NoCols; ++j) { for (int k = 0; k < rowNumber[i, j]; ++k) { for (int l = 0; l < colNumber[i, j]; ++l) { BPosition pos = pattern._relativePositions[i, j]; pos.Pt = vOffset + new Vector2D( k * pattern.PatternStep.X + pos.Pt.X , l * pattern.PatternStep.Y + pos.Pt.Y); solution.Add(pos); } } } } foreach (var p in lPosRight) { solution.Add(new BPosition(p.Pt + vOffset + SpaceBetween.X * Vector2D.XAxis, p.Angle)); } foreach (var p in lPosTop) { solution.Add(new BPosition(p.Pt + vOffset + SpaceBetween.Y * Vector2D.YAxis, p.Angle)); } // noRows / noCols solution.Rows = pattern.NoCols * noPatternX + iMax + 1; solution.Cols = pattern.NoRows * noPatternY + jMax + 1; // cardboard position solution.CardboardPosition = Vector2D.Zero; solution.CardboardDimensions = FormatDimensions; return(solution); }
internal override ImpositionSolution GenerateSolution(ImpositionPattern pattern) { // instantiate solution ImpositionSolution solution = new ImpositionSolution(InitialEntities, pattern.Name, pattern.RequiresRotationInRows, pattern.RequiresRotationInColumns); // pattern global box Box2D boxGlobal = pattern.BBox; // compute max number of patterns int noPatternX = NoPatternX(pattern); int noPatternY = NoPatternY(pattern); int[,] rowNumber = new int[pattern.NoRows, pattern.NoCols]; int[,] colNumber = new int[pattern.NoRows, pattern.NoCols]; int iMax = -1, jMax = -1; for (int i = 0; i < pattern.NoRows; ++i) { for (int j = 0; j < pattern.NoCols; ++j) { if (pattern._bboxes[i, j].XMax + noPatternX * pattern.PatternStep.X - boxGlobal.XMin < UsableFormat.Width) { rowNumber[i, j] = noPatternX + 1; iMax = i; } else { rowNumber[i, j] = noPatternX; } if (pattern._bboxes[i, j].YMax + noPatternY * pattern.PatternStep.Y - boxGlobal.YMin < UsableFormat.Height) { colNumber[i, j] = noPatternY + 1; jMax = j; } else { colNumber[i, j] = noPatternY; } } } // compute actual margin double xMax = double.MinValue; double yMax = double.MinValue; for (int i = 0; i < pattern.NoRows; ++i) { for (int j = 0; j < pattern.NoCols; ++j) { xMax = Math.Max(xMax, pattern._bboxes[i, j].XMax + (rowNumber[i, j] - 1) * pattern.PatternStep.X); yMax = Math.Max(yMax, pattern._bboxes[i, j].YMax + (colNumber[i, j] - 1) * pattern.PatternStep.Y); } } double xMargin = 0.0; switch (HorizontalAlignment) { case ImpositionTool.HAlignment.HALIGN_LEFT: xMargin = UsableFormat.XMin; break; case ImpositionTool.HAlignment.HALIGN_RIGHT: xMargin = CardboardFormat.Width - Margin.X - xMax + boxGlobal.XMin; break; case ImpositionTool.HAlignment.HALIGN_CENTER: xMargin = (CardboardFormat.Width - xMax + boxGlobal.XMin) * 0.5; break; default: break; } double yMargin = 0.0; switch (VerticalAlignment) { case ImpositionTool.VAlignment.VALIGN_BOTTOM: yMargin = UsableFormat.YMin; break; case ImpositionTool.VAlignment.VALIGN_TOP: yMargin = CardboardFormat.Height - Margin.Y - yMax + boxGlobal.YMin; break; case ImpositionTool.VAlignment.VALIGN_CENTER: yMargin = (CardboardFormat.Height - yMax + boxGlobal.YMin) * 0.5; break; default: break; } // compute offsets double xOffset = xMargin - boxGlobal.XMin; double yOffset = yMargin - boxGlobal.YMin; for (int i = 0; i < pattern.NoRows; ++i) { for (int j = 0; j < pattern.NoCols; ++j) { for (int k = 0; k < rowNumber[i, j]; ++k) { for (int l = 0; l < colNumber[i, j]; ++l) { BPosition pos = pattern._relativePositions[i, j]; pos._pt.X = xOffset + k * pattern.PatternStep.X + pos._pt.X; pos._pt.Y = yOffset + l * pattern.PatternStep.Y + pos._pt.Y; solution.Add(pos); } } } } // noRows / noCols solution.Rows = pattern.NoCols * noPatternX + iMax + 1; solution.Cols = pattern.NoRows * noPatternY + jMax + 1; // cardboard position solution.CardboardPosition = new Vector2D(xMargin, yMargin); solution.CardboardDimensions = _cardboardFormat.Dimensions; return(solution); }