private static void CreateSplittedLines(IStep step, IFilter filter, IODBObject evtlLine2, ILineSpecificsD line2, PointD pDest, ref List <IODBObject> selectedElements) { PointD lastEnd = line2.End; line2.End = pDest; if (Math.Abs(IMath.DistancePointToPoint(line2.End, line2.Start)) < errorLevel) { line2.End = lastEnd; line2.Start = pDest; if (Math.Abs(IMath.DistancePointToPoint(line2.End, line2.Start)) > errorLevel) { evtlLine2.SetSpecifics(line2); } else { Debug.WriteLine("Line with length 0!"); } } else { evtlLine2.SetSpecifics(line2); ILayer parentLayer = step.GetLayer(evtlLine2.GetParentLayerName()); if (parentLayer != null) { IODBObject line2Part2 = filter.CreateLine((IODBLayer)parentLayer); line2.End = lastEnd; line2.Start = pDest; line2Part2.SetSpecifics(line2); selectedElements.Add(line2Part2); } } }
public void Execute(IPCBIWindow parent) { IFilter filter = new IFilter(parent); IStep curStep = parent.GetCurrentStep(); if (curStep == null) { MessageBox.Show("No Job loaded, please load a job before start this script!", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Asterisk); return; } IODBLayer fiducialLayer = filter.CreateEmptyODBLayer("fiducial", curStep.Name); if (fiducialLayer == null) { MessageBox.Show("Can't create new layer!", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Asterisk); return; } int shapeIndex = IFilter.AddToolDefinitionDonut(fiducialLayer, (float)IMath.MM2Mils(2), (float)IMath.MM2Mils(1), -1); IODBObject pad = filter.CreatePad(fiducialLayer); PointD FidPoint = new PointD(IMath.MM2Mils(3), IMath.MM2Mils(3)); pad.SetSpecifics(new IPadSpecificsD() { Location = FidPoint, ShapeIndex = shapeIndex, Positive = true }); IAttributeElement attribute = new IAttributeElement(PCBI.FeatureAttributeEnum.fiducial_name); attribute.Value = "fid1"; IAttribute.SetAttribute(attribute, pad); FidPoint = new PointD(IMath.MM2Mils(3), IMath.MM2Mils(147)); pad = filter.CreatePad(fiducialLayer); pad.SetSpecifics(new IPadSpecificsD() { Location = FidPoint, ShapeIndex = shapeIndex, Positive = true }); attribute = new IAttributeElement(PCBI.FeatureAttributeEnum.fiducial_name); attribute.Value = "fid1"; IAttribute.SetAttribute(attribute, pad); parent.UpdateControlsAndResetView(); }
private static void CreateBoardView(IStep step, IFilter filter, IODBLayer frontLayer, float boardThickness, bool front) { if (boardThickness > 0) { #region draw board front int shapeIndexBoardHeight = IFilter.AddToolDefinitionRect(frontLayer, boardThickness, boardThickness, boardThickness, false); //add line with board symbol index to have correct thickness IODBObject boardLineFront = filter.CreateLine(frontLayer); ILineSpecificsD lineDetails = (ILineSpecificsD)boardLineFront.GetSpecificsD(); if (front) { lineDetails.Start = new PointD(step.GetBoundsD().Left + boardThickness / 2, 0); lineDetails.End = new PointD(step.GetBoundsD().Right - boardThickness / 2, 0); } else { lineDetails.Start = new PointD(0, step.GetBoundsD().Top + boardThickness / 2); lineDetails.End = new PointD(0, step.GetBoundsD().Bottom - boardThickness / 2); } boardLineFront.SetSpecifics(lineDetails, shapeIndexBoardHeight); boardLineFront.ObjectColorTemporary(Color.Green); #endregion } }
private static void AddDrillObjects(IFilter filter, ILayer drill_layer, MatrixLayerType type, IODBLayer odb_sig_layer) { Dictionary <int, int> symbolUsed = new Dictionary <int, int>(); foreach (IODBObject obj in drill_layer.GetAllLayerObjects()) { #region one drill layer obj.Select(true); if (obj.Type == IObjectType.Pad) { IPadSpecifics ops = (IPadSpecifics)obj.GetSpecifics(); if (type != MatrixLayerType.Dielectric) { ops.Positive = false; } else { ops.Positive = true; } if (!symbolUsed.ContainsKey(ops.ShapeIndex)) { int index = IFilter.AddToolFromODBString(odb_sig_layer, ops.ODBSymbol_String); symbolUsed.Add(ops.ShapeIndex, index); } ops.ShapeIndex = symbolUsed[ops.ShapeIndex]; IODBObject pad = filter.CreatePad(odb_sig_layer); pad.SetSpecifics(ops); } else if (obj.Type == IObjectType.Line) { ILineSpecifics ops = (ILineSpecifics)obj.GetSpecifics(); if (type != MatrixLayerType.Dielectric) { ops.Positive = false; } else { ops.Positive = true; } if (!symbolUsed.ContainsKey(ops.ShapeIndex)) { int index = IFilter.AddToolFromODBString(odb_sig_layer, ops.ODBSymbol_String); symbolUsed.Add(ops.ShapeIndex, index); } ops.ShapeIndex = symbolUsed[ops.ShapeIndex]; IODBObject line = filter.CreateLine(odb_sig_layer); line.SetSpecifics(ops); } #endregion } }
private static void CreateVertLine(IFilter filter, IODBLayer rasterLayer, int shapeIndex, int y, int x) { IODBObject rasterLine = filter.CreateLine(rasterLayer); ILineSpecificsD line = (ILineSpecificsD)rasterLine.GetSpecificsD(); line.Start = new PCBI.MathUtils.PointD(x, y); line.End = new PCBI.MathUtils.PointD(x, y + 50); line.ShapeIndex = shapeIndex; rasterLine.SetSpecifics(line); }
private void CopyAllViasToNewLayer(IPCBIWindow parent, string layerName, string newLayerName) { IStep curStep = parent.GetCurrentStep(); if (curStep == null) { MessageBox.Show("No Job loaded, please load a job before start this script!", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Asterisk); return; } ILayer relevantLayer = curStep.GetLayer(layerName); ILayer NewLayer = curStep.GetLayer(newLayerName); if (NewLayer == null || relevantLayer == null || !(NewLayer is IODBLayer)) { MessageBox.Show("Check Layers, something is wrong!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } List <IODBObject> ViaList = new List <IODBObject>(); //check all elements for via attribute foreach (IObject obj in relevantLayer.GetAllLayerObjects()) { if (obj is IODBObject) { if (((IODBObject)obj).Type == IObjectType.Pad) { Dictionary <PCBI.FeatureAttributeEnum, string> attributesOfPad = ((IODBObject)obj).GetAttributesDictionary(); if (attributesOfPad.ContainsKey(PCBI.FeatureAttributeEnum.pad_usage)) { if (attributesOfPad[PCBI.FeatureAttributeEnum.pad_usage] == "via") { ViaList.Add((IODBObject)obj); } } } } } IFilter filter = new IFilter(parent); //to create copies on new layer //add vias to new layer foreach (IODBObject viaPad in ViaList) { IPadSpecificsD padInfo = (IPadSpecificsD)viaPad.GetSpecificsD(); int toolNr = IFilter.AddToolDefinitionRound((IODBLayer)NewLayer, (float)padInfo.Diameter, -1); IODBObject newViaPad = filter.CreatePad((IODBLayer)NewLayer); newViaPad.SetSpecifics(padInfo, toolNr); newViaPad.SetAttribute("pad_usage=via"); } }
public void CreateCopperLines() { IFilter filter = new IFilter(Parent); IStep curStep = Parent.GetCurrentStep(); if (curStep == null) { MessageBox.Show("No Job loaded, please load a job before start this script!", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Asterisk); return; } IODBLayer fiducialLayer = filter.CreateEmptyODBLayer("copper", curStep.Name); if (fiducialLayer == null) { MessageBox.Show("Can't create new layer!", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Asterisk); return; } float outerDiameter = 1800; int shapeIndex = IFilter.AddToolDefinitionRound(fiducialLayer, outerDiameter / 25.4f, 0); PCBI.MathUtils.PointD startLine = new PCBI.MathUtils.PointD(0, 0); float distance = 2540 / 25.4f; for (int y = 0; y < 39; y++) { float lastX = 0; for (int i = 0; i < 63; i++) { IODBObject line = filter.CreateLine(fiducialLayer); ILineSpecificsD ps = new ILineSpecificsD(); ps.Start = new PCBI.MathUtils.PointD(startLine.X, startLine.Y); float lineEnd = lastX + distance; ps.End = new PCBI.MathUtils.PointD(lineEnd, startLine.Y); lastX = lineEnd; ps.ShapeIndex = shapeIndex; ps.Positive = true; line.SetSpecifics(ps); startLine.X += distance; } startLine.Y += distance; startLine.X = 0; } IMatrix matrix = Parent.GetMatrix(); matrix.UpdateDataAndList(); Parent.UpdateView(); }
public void Execute(IPCBIWindow parent) { IStep step = parent.GetCurrentStep(); if (step == null) { return; } IFilter PCBI_filter = new IFilter(parent); IODBLayer newOutlineLayer = PCBI_filter.CreateEmptyODBLayer("poly_to_line", step.Name); float LineWith = 10; //diameter symbol foreach (IODBObject obj in step.GetSelectedElements()) { foreach (IObjectSpecifics os in obj.GetOutline()) { if (os.GetType() == typeof(ILineSpecifics)) { ILineSpecifics lineEdges = (ILineSpecifics)os; IODBObject line = PCBI_filter.CreateLine(newOutlineLayer); lineEdges.ShapeIndex = CheckShapeIndexRound(PCBI_filter, newOutlineLayer, LineWith); lineEdges.Type = PCBI.Symbol_Type.r; line.SetSpecifics(lineEdges, lineEdges.ShapeIndex); } else if (os.GetType() == typeof(IArcSpecifics)) { IArcSpecifics arcEdges = (IArcSpecifics)os; IODBObject arc = PCBI_filter.CreateArc(newOutlineLayer); arcEdges.ShapeIndex = CheckShapeIndexRound(PCBI_filter, newOutlineLayer, LineWith); arcEdges.Type = PCBI.Symbol_Type.r; arc.SetSpecifics(arcEdges, arcEdges.ShapeIndex); } } } parent.UpdateView(); IMatrix matrix = parent.GetMatrix(); matrix.UpdateDataAndList(); }
private void CreateNewDrillODBLayer(PCBI.Automation.IFilter filter, string newLayerName, IPCBIWindow parent, List <IODBObject> currIODBObjectList, bool activateLayer) { if (currIODBObjectList.Count == 0) { return; } IODBLayer layer = filter.CreateEmptyODBLayer(newLayerName, parent.GetCurrentStep().Name); Dictionary <string, int> shapeList = new Dictionary <string, int>(); foreach (IODBObject obj in currIODBObjectList) { if (obj.Type == IObjectType.Pad) { IPadSpecificsD specPad = (IPadSpecificsD)obj.GetSpecificsD(); if (!shapeList.ContainsKey(specPad.ODBSymbol_String)) { int newShapeIndex = IFilter.AddToolFromODBString(layer, specPad.ODBSymbol_String, shapeList.Count); shapeList.Add(specPad.ODBSymbol_String, newShapeIndex); } IODBObject pad = filter.CreatePad(layer); IPadSpecificsD padInfosD = (IPadSpecificsD)obj.GetSpecificsD(); padInfosD.ShapeIndex = shapeList[specPad.ODBSymbol_String]; pad.SetSpecifics(padInfosD, shapeList[specPad.ODBSymbol_String]); } else if (obj.Type == IObjectType.Line) { ILineSpecificsD specLine = (ILineSpecificsD)obj.GetSpecificsD(); if (!shapeList.ContainsKey(specLine.ODBSymbol_String)) { int newShapeIndex = IFilter.AddToolFromODBString(layer, specLine.ODBSymbol_String, shapeList.Count); shapeList.Add(specLine.ODBSymbol_String, newShapeIndex); } IODBObject line = filter.CreateLine(layer); ILineSpecificsD lineSpecificsD = (ILineSpecificsD)obj.GetSpecificsD(); lineSpecificsD.ShapeIndex = shapeList[specLine.ODBSymbol_String]; line.SetSpecifics(lineSpecificsD); } else if (obj.Type == IObjectType.Arc) { IArcSpecificsD specArc = (IArcSpecificsD)obj.GetSpecificsD(); if (!shapeList.ContainsKey(specArc.ODBSymbol_String)) { int newShapeIndex = IFilter.AddToolFromODBString(layer, specArc.ODBSymbol_String, shapeList.Count); shapeList.Add(specArc.ODBSymbol_String, newShapeIndex); } IODBObject arc = filter.CreateArc(layer); IArcSpecificsD specificsArcD = (IArcSpecificsD)obj.GetSpecificsD(); specificsArcD.ShapeIndex = shapeList[specArc.ODBSymbol_String]; arc.SetSpecifics(specificsArcD); } else if (obj.Type == IObjectType.Surface) { IODBObject surface = filter.CreatePolygon(layer); ISurfaceSpecificsD surfaceSpecificsD = (ISurfaceSpecificsD)obj.GetSpecificsD(); surface.SetSpecifics(surfaceSpecificsD); } else if (obj.Type == IObjectType.Text) { IODBObject text = filter.CreateText(layer); ITextSpecificsD textSpecificsD = (ITextSpecificsD)obj.GetSpecificsD(); text.SetSpecifics(textSpecificsD); } } if (activateLayer) { layer.EnableLayer(true); } IMatrix matrix = parent.GetMatrix(); matrix.SetMatrixLayerType(layer.LayerName, MatrixLayerType.Drill); matrix.SetMatrixLayerContext(layer.LayerName, MatrixLayerContext.Board); }
public void Execute(IPCBIWindow parent) { IStep step = parent.GetCurrentStep(); IMatrix matrix = parent.GetMatrix(); if (step == null || matrix == null) { return; } IODBLayer IODBLayerOrg = null; IODBLayer IODBLayerNew = null; foreach (ILayer activeLayer in step.GetActiveLayerList()) //search for the first two active layer to copy from first to second { if (activeLayer is IODBLayer) { if (IODBLayerOrg == null) { IODBLayerOrg = (IODBLayer)activeLayer; } else if (IODBLayerNew == null) { IODBLayerNew = (IODBLayer)activeLayer; } else { break; //only the first two layers... } } } if (IODBLayerOrg == null || IODBLayerNew == null) { return; } IFilter filter = new IFilter(parent); if (IODBLayerOrg is IODBLayer) { Dictionary <int, int> ShapeIndexOldNew = new Dictionary <int, int>(); //set new shape index if symbol is created. foreach (IODBObject obj in IODBLayerOrg.GetAllLayerObjects()) { IODBObject objNew = null; IObjectSpecificsD spec = obj.GetSpecificsD(); switch (obj.Type) { case IObjectType.Arc: objNew = filter.CreateArc(IODBLayerNew); if (!ShapeIndexOldNew.ContainsKey(((IArcSpecificsD)spec).ShapeIndex)) { int indexNew = IFilter.AddToolFromODBString(IODBLayerNew, ((IArcSpecificsD)spec).ODBSymbol_String); ShapeIndexOldNew.Add(((IArcSpecificsD)spec).ShapeIndex, indexNew); } ((IArcSpecificsD)spec).ShapeIndex = ShapeIndexOldNew[((IArcSpecificsD)spec).ShapeIndex]; break; case IObjectType.Line: objNew = filter.CreateLine(IODBLayerNew); if (!ShapeIndexOldNew.ContainsKey(((ILineSpecificsD)spec).ShapeIndex)) { int indexNew = IFilter.AddToolFromODBString(IODBLayerNew, ((ILineSpecificsD)spec).ODBSymbol_String); ShapeIndexOldNew.Add(((ILineSpecificsD)spec).ShapeIndex, indexNew); } ((ILineSpecificsD)spec).ShapeIndex = ShapeIndexOldNew[((ILineSpecificsD)spec).ShapeIndex]; break; case IObjectType.Pad: objNew = filter.CreatePad(IODBLayerNew); if (!ShapeIndexOldNew.ContainsKey(((IPadSpecificsD)spec).ShapeIndex)) { IFilter.ToolDefinition toolDef = filter.GetSymbolByShapeIndex(((IPadSpecificsD)spec).ShapeIndex, (IODBLayer)IODBLayerOrg); int indexNew = -1; if (toolDef.Type == PCBI.Symbol_Type.special) { indexNew = IFilter.AddToolDefinitionSpecial(IODBLayerNew, (IODBLayer)IODBLayerOrg, toolDef.ShapeIndex); } else { indexNew = IFilter.AddToolFromODBString(IODBLayerNew, ((IPadSpecificsD)spec).ODBSymbol_String); } ShapeIndexOldNew.Add(((IPadSpecificsD)spec).ShapeIndex, indexNew); } ((IPadSpecificsD)spec).ShapeIndex = ShapeIndexOldNew[((IPadSpecificsD)spec).ShapeIndex]; break; case IObjectType.Surface: objNew = filter.CreatePolygon(IODBLayerNew); break; case IObjectType.Text: objNew = filter.CreateText(IODBLayerNew); break; default: System.Diagnostics.Debug.WriteLine("Case not possible!"); break; } if (objNew != null) { objNew.SetSpecifics(spec); } } } else { System.Diagnostics.Debug.WriteLine("Not implemented for components!"); } parent.UpdateView(); }
public void Execute(IPCBIWindow parent) { IStep step = parent.GetCurrentStep(); if (step == null) { return; } if (step.GetSelectedElementsCount() == 2) //this script is optimiezd for two line elements { List <IODBObject> selectedElements = step.GetSelectedElements(); IODBObject obj1 = selectedElements[0]; IODBObject obj2 = selectedElements[1]; bool firstArc = false; bool secondArc = false; if (obj1.Type == IObjectType.Arc) { firstArc = true; } if (obj2.Type == IObjectType.Arc) { secondArc = true; } if (!firstArc && obj1.Type != IObjectType.Line) { return; } else if (!secondArc && obj2.Type != IObjectType.Line) { return; } ILineSpecificsD obS1; ILineSpecificsD obS2; if (firstArc) { obS1 = new ILineSpecificsD(); IArcSpecificsD arcS1 = (IArcSpecificsD)obj1.GetSpecificsD(); obS1.Start = arcS1.Start; obS1.End = arcS1.End; } else { obS1 = (ILineSpecificsD)obj1.GetSpecificsD(); } if (secondArc) { obS2 = new ILineSpecificsD(); IArcSpecificsD arcS2 = (IArcSpecificsD)obj2.GetSpecificsD(); obS2.Start = arcS2.Start; obS2.End = arcS2.End; } else { obS2 = (ILineSpecificsD)obj2.GetSpecificsD(); } //make simple check for crossing point, this is nearly correct for arc endings PCBI.MathUtils.PointD crossingPoint = PCBI.MathUtils.IMath.CrossingPoint(obS1.Start, obS1.End, obS2.Start, obS2.End, false); if (PCBI.MathUtils.PointD.InfPoint == crossingPoint) { return; //parallel lines do not work } #region set ends of lines to the crossing Point if (!firstArc) { if (PCBI.MathUtils.IMath.DistancePointToPoint(crossingPoint, obS1.End) < PCBI.MathUtils.IMath.DistancePointToPoint(crossingPoint, obS1.Start)) { obS1.End = crossingPoint; } else { obS1.Start = crossingPoint; } obj1.SetSpecifics(obS1); } else { //special case for arc IArcSpecificsD arcS1 = (IArcSpecificsD)obj1.GetSpecificsD(); if (PCBI.MathUtils.IMath.DistancePointToPoint(crossingPoint, obS1.End) < PCBI.MathUtils.IMath.DistancePointToPoint(crossingPoint, obS1.Start)) { arcS1.End = crossingPoint; } else { arcS1.Start = crossingPoint; } obj1.SetSpecifics(arcS1); obj1.UpdateInternal(); } if (!secondArc) { if (PCBI.MathUtils.IMath.DistancePointToPoint(crossingPoint, obS2.End) < PCBI.MathUtils.IMath.DistancePointToPoint(crossingPoint, obS2.Start)) { obS2.End = crossingPoint; } else { obS2.Start = crossingPoint; } obj2.SetSpecifics(obS2); } else { //special case for arc IArcSpecificsD arcS2 = (IArcSpecificsD)obj2.GetSpecificsD(); if (PCBI.MathUtils.IMath.DistancePointToPoint(crossingPoint, arcS2.End) < PCBI.MathUtils.IMath.DistancePointToPoint(crossingPoint, arcS2.Start)) { arcS2.End = crossingPoint; } else { arcS2.Start = crossingPoint; } obj2.SetSpecifics(arcS2); obj2.UpdateInternal(); } #endregion } parent.UpdateView(); }
private static void CreateComponents(bool top, ICMPLayer CMPLayer, IODBLayer frontLayer, IODBLayer sideLayer, float offset, IFilter filter, bool allValuesInMM) { if (CMPLayer == null) { return; } foreach (ICMPObject component in CMPLayer.GetAllLayerObjects()) { float height = (float)component.CompHEIGHT; IPackageSpecificsD usedPackage = component.GetPackageSpecificsD(); if (height == 0) { height = usedPackage.Height; } if (height == 0) { #region check height //check attributes foreach (string attrib in component.GetComponentAttributes()) { if (attrib.ToLowerInvariant().Contains("height")) { string[] attribtValueFinder = attrib.Split('='); if (attribtValueFinder.Length > 1) { float.TryParse(attribtValueFinder[1], System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out height); } else if (attribtValueFinder[0].Contains("\'")) { string subStr = attribtValueFinder[0].Substring(attribtValueFinder[0].IndexOf('\'') + 1); if (subStr.Contains("\'")) { subStr = subStr.Substring(0, subStr.IndexOf('\'')); float.TryParse(subStr, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out height); } } } } #endregion } if (allValuesInMM) { height = (float)IMath.MM2Mils(height); } #region front layer int componentFront = IFilter.AddToolDefinitionRect(frontLayer, (float)component.Bounds.Width, height, (float)component.Bounds.Width, false); IODBObject cmpFront = filter.CreatePad(frontLayer); IPadSpecificsD padCMPFront = (IPadSpecificsD)cmpFront.GetSpecificsD(); if (top) { padCMPFront.Location = new PointD(component.Bounds.X + component.Bounds.Width / 2, offset + height / 2); } else { padCMPFront.Location = new PointD(component.Bounds.X + component.Bounds.Width / 2, -(offset + height / 2)); } cmpFront.SetSpecifics(padCMPFront, componentFront); cmpFront.FreeText = component.Ref; if (top) { cmpFront.ObjectColorTemporary(Color.Silver); } else { cmpFront.ObjectColorTemporary(Color.Gray); } #endregion #region side layer int componentSide = IFilter.AddToolDefinitionRect(sideLayer, (float)component.Bounds.Height, (float)component.Bounds.Height, height, false); IODBObject cmpSide = filter.CreatePad(sideLayer); IPadSpecificsD padCMPSide = (IPadSpecificsD)cmpSide.GetSpecificsD(); if (top) { padCMPSide.Location = new PointD(offset + height / 2, component.Bounds.Y + component.Bounds.Height / 2); } else { padCMPSide.Location = new PointD(-(offset + height / 2), component.Bounds.Y + component.Bounds.Height / 2); } cmpSide.SetSpecifics(padCMPSide, componentSide); cmpSide.FreeText = component.Ref; if (top) { cmpSide.ObjectColorTemporary(Color.Silver); } else { cmpSide.ObjectColorTemporary(Color.Gray); } #endregion } }
public void Execute(IPCBIWindow parent) { if (parent.GetCurrentStep() == null) { return; } bool clearLayer = false; IStep step = parent.GetCurrentStep(); IODBLayer layerTopPins = null; IODBLayer layerbotPins = null; IFilter filter = new IFilter(parent); if (layerTopPins == null) { layerTopPins = filter.CreateEmptyODBLayer("component_top_shapes", step.Name); if (clearLayer) { foreach (IODBObject o in layerTopPins.GetAllLayerObjects()) { layerTopPins.RemoveObject(o); } } } if (layerbotPins == null) { layerbotPins = filter.CreateEmptyODBLayer("component_bot_shapes", step.Name); if (clearLayer) { foreach (IODBObject o in layerbotPins.GetAllLayerObjects()) { layerbotPins.RemoveObject(o); } } } // Pins foreach (ICMPObject cmp in step.GetAllCMPObjects()) { foreach (IPin pin in cmp.GetPinList()) { IODBObject outlinePolygon = null; if (cmp.PlacedTop) { outlinePolygon = filter.CreatePolygon(layerTopPins); } else { outlinePolygon = filter.CreatePolygon(layerbotPins); } ISurfaceSpecifics specOutline = (ISurfaceSpecifics)outlinePolygon.GetSpecifics(); bool polyStart = true; PointF StartPoint = new PointF(0, 0); PointF EndPoint = new PointF(0, 0); foreach (IEdge edge in pin.GetPolygonOutline(cmp).GetEdges()) { if (polyStart) { polyStart = false; StartPoint = new PointF((float)edge.Begin.X, (float)edge.Begin.Y); specOutline.StartPolygon(false, StartPoint); if (edge is IArcEdge) { IArcEdge aEdge = (IArcEdge)edge; PointF start = new PointF((float)aEdge.Begin.X, (float)aEdge.Begin.Y); PointF end = new PointF((float)aEdge.End.X, (float)aEdge.End.Y); PointF center = new PointF((float)aEdge.Center.X, (float)aEdge.Center.Y); specOutline.AddArc(start, end, center, aEdge.ClockWise); if (aEdge.ClockWise) { EndPoint = end; } else { EndPoint = start; } } else if (edge is ILineEdge) { ILineEdge aEdge = (ILineEdge)edge; PointF start = new PointF((float)aEdge.Begin.X, (float)aEdge.Begin.Y); PointF end = new PointF((float)aEdge.End.X, (float)aEdge.End.Y); specOutline.AddLine(start, end); EndPoint = end; } } else if (edge is IArcEdge) { IArcEdge aEdge = (IArcEdge)edge; PointF start = new PointF((float)aEdge.Begin.X, (float)aEdge.Begin.Y); PointF end = new PointF((float)aEdge.End.X, (float)aEdge.End.Y); PointF center = new PointF((float)aEdge.Center.X, (float)aEdge.Center.Y); specOutline.AddArc(start, end, center, aEdge.ClockWise); if (aEdge.ClockWise) { EndPoint = end; } else { EndPoint = start; } } else if (edge is ILineEdge) { ILineEdge aEdge = (ILineEdge)edge; PointF start = new PointF((float)aEdge.Begin.X, (float)aEdge.Begin.Y); PointF end = new PointF((float)aEdge.End.X, (float)aEdge.End.Y); specOutline.AddLine(start, end); EndPoint = end; } } specOutline.EndPolygon(); //close the new contour outlinePolygon.SetSpecifics(specOutline); outlinePolygon.ObjectColor = Color.Blue; } } layerbotPins.EnableLayer(true); layerTopPins.EnableLayer(true); parent.UpdateView(); parent.UpdateControlsAndResetView(); }
internal static bool CutRectangle(IPolyClass rectanglePoly, IODBLayer layer, IODBLayer NewlayerToAddElements, IFilter filter, IPCBIWindow parentPCBI) { if (layer == null) { return(false); //no layer } if (NewlayerToAddElements == null) { return(false); //no layer for new elements } //use bounds to get relevant objects //cut intersecting objects //helper for Symbols Dictionary <int, int> symbolUsed = new Dictionary <int, int>(); //Performance RectangleD relevantRectangle = rectanglePoly.GetBounds(); foreach (IODBObject obj in layer.GetAllLayerObjects()) { if (relevantRectangle.IntersectsWith(obj.GetBoundsD())) { #region cut elements //cutting IPolyClass polygon = obj.GetPolygonOutline(); IPolyClass cuttingPolygon; if (rectanglePoly.GetBounds().Contains(polygon.GetBounds())) { cuttingPolygon = polygon; } else { cuttingPolygon = polygon.Intersect(rectanglePoly); } if (cuttingPolygon.GetEdgeCount() == 0) { continue; //bounds cutting but not of any interest } List <ISurfaceSpecificsD> subPolygons = cuttingPolygon.SplitInIsleAndHoles(parentPCBI, NewlayerToAddElements); foreach (ISurfaceSpecificsD subPolygon in subPolygons) //create part surfaces { IODBObject surface = filter.CreatePolygon(NewlayerToAddElements); subPolygon.Positive = obj.Positive; surface.SetSpecifics(subPolygon); Dictionary <string, string> attributes = obj.GetAttributesDictionaryStringKeys(); foreach (string attribute in attributes.Keys) { surface.SetAttribute(attributes[attribute], attribute); //copy attributes } } #endregion } else { //not relevant -> ignore } } return(true); //finish }
public void Execute(IPCBIWindow parent) { IFilter filter = new IFilter(parent); IStep curStep = parent.GetCurrentStep(); if (curStep == null) { return; } List <IODBObject> selectedElements = curStep.GetSelectedElements(); //create list with all selected elements to make a new symbol of it List <IObjectSpecificsD> newSymbolSpecs = new List <IObjectSpecificsD>(); string relLayerName = ""; PCBI.MathUtils.RectangleD bounds = new PCBI.MathUtils.RectangleD(); int indexOfLastElement = 1; foreach (IODBObject obj in selectedElements) { newSymbolSpecs.Add(obj.GetSpecificsD()); relLayerName = obj.GetParentLayerName(); if (bounds == RectangleD.Empty) { bounds = obj.GetBoundsD(); } else { bounds = PCBI.MathUtils.RectangleD.Union(bounds, obj.GetBoundsD()); } indexOfLastElement = obj.GetIndexOnLayer(); } IODBLayer relLayer = (IODBLayer)curStep.GetLayer(relLayerName); if (relLayer == null) { return; } //create new symbol for pads, the name must be unique. We try it with the index of one of the elements. int nr = IFilter.AddToolDefinitionSpecial(relLayer, parent, "testsymbol3" + indexOfLastElement, newSymbolSpecs, -bounds.GetMidPoint().X, -bounds.GetMidPoint().Y); if (nr < 0) { //no new symbol was created, maybe name is already existing return; } //delete old elements IAutomation.SuppressUserNotifications = false; //otherwise the delete action will be blocked parent.UIAction.Execute(ID_ActionItem.ID_DELETE); IODBObject pad = filter.CreatePad(relLayer); IPadSpecificsD padSpec = (IPadSpecificsD)pad.GetSpecificsD(); padSpec.Location = bounds.GetMidPoint(); pad.SetSpecifics(padSpec, nr); pad.SetAttribute("new symbol attribute"); pad.Select(true); parent.UpdateView(); }
void CreateForOneSide(bool top, IStep step, IFilter filter, string PackageName, List <string> DrillLayers) { ICMPLayer compLayer = step.GetCMPLayer(top); if (compLayer == null) { return; } IODBLayer newLayer = filter.CreateEmptyODBLayer("testpoint_locations_" + (top ? "top" : "bot"), step.Name); if (newLayer == null) { return; } List <IODBLayer> allDrillLayers = new List <IODBLayer>(); foreach (string drillName in DrillLayers) { allDrillLayers.Add((IODBLayer)step.GetLayer(drillName)); } int shapeIndex = IFilter.AddToolDefinitionRound(newLayer, 75); int shapeIndexConnection = IFilter.AddToolDefinitionRound(newLayer, 1); foreach (ICMPObject cmp in compLayer.GetAllLayerObjects()) { if (!cmp.UsedPackageName.Contains(PackageName)) { continue; } IODBObject markerPad = filter.CreatePad(newLayer); IPadSpecificsD pad = (IPadSpecificsD)markerPad.GetSpecificsD(); pad.Location = new PCBI.MathUtils.PointD(cmp.Position); pad.ShapeIndex = shapeIndex; markerPad.SetSpecifics(pad); markerPad.ObjectColor = Color.Green; markerPad.SetAttribute("Steel needle <BST> (Testpoint)"); bool special = false; foreach (IODBLayer drillLayer in allDrillLayers) { #region check drills foreach (IODBObject drill in drillLayer.GetAllObjectsOnPosition(cmp.Position)) { Dictionary <PCBI.FeatureAttributeEnum, string> attribs = drill.GetAttributesDictionary(); if (attribs.ContainsKey(PCBI.FeatureAttributeEnum.drill)) { if (attribs[PCBI.FeatureAttributeEnum.drill].ToUpperInvariant() == "VIA") { markerPad.ObjectColor = Color.Blue; markerPad.SetAttribute("Pyramid <H> (Via)"); special = true; break; } } } if (special) { break; } #endregion } if (!special) { //check for component pin foreach (ICMPObject comp in compLayer.GetAllObjectsOnPosition(cmp.Position)) { if (comp == cmp) { continue; //testpunkt selbst wird ignoriert } foreach (IPin pin in comp.GetPinList()) { PCBI.MathUtils.IPolyClass cmpPoly = pin.GetPolygonOutline(comp); if (cmpPoly.PointInPolygon(pad.Location)) { markerPad.ObjectColor = Color.Red; markerPad.SetAttribute("Serrated <C>"); //hier evtl noch überprüfen ob pin bzw. body drüber liegt? special = true; //oder Serrated with overlapping plastic <CS> break; } } if (special) { break; } } } } foreach (ICMPObject cmp in compLayer.GetAllLayerObjects()) //neue schleife da erst alle pads plaziert werden sollen! { if (!cmp.UsedPackageName.Contains(PackageName)) { continue; } IODBObject textForPad = filter.CreateText(newLayer); ITextSpecificsD text = (ITextSpecificsD)textForPad.GetSpecificsD(); text.Text = cmp.Ref.Remove(0, 2); //Annahme das alle mit TP beginnen text.TextSize = new SizeF(25, 50); text.Location = new PCBI.MathUtils.PointD(cmp.Position.X + 50, cmp.Position.Y - 10); text.WidthFactor = 0.6; textForPad.SetSpecifics(text); textForPad.ObjectColor = Color.DarkGray; //text location should not be intersecting! List <IObject> otherObjectsOnSameLocation = newLayer.GetAllObjectInRectangle(textForPad.GetBoundsD()); int offset = 50; bool horChecked = false; while (otherObjectsOnSameLocation.Count > 1) { //move text if (horChecked) { text.Location = new PCBI.MathUtils.PointD(cmp.Position.X, cmp.Position.Y + offset); } else { text.Location = new PCBI.MathUtils.PointD(cmp.Position.X - offset - textForPad.GetBoundsD().Width, cmp.Position.Y - 10); } offset += 50; horChecked = true; textForPad.SetSpecifics(text); otherObjectsOnSameLocation = newLayer.GetAllObjectInRectangle(textForPad.GetBoundsD()); } IODBObject connectionLine = filter.CreateLine(newLayer); ILineSpecificsD line = (ILineSpecificsD)connectionLine.GetSpecificsD(); line.ShapeIndex = shapeIndexConnection; line.Start = new PCBI.MathUtils.PointD(cmp.Position); line.End = new PCBI.MathUtils.PointD(text.Location.X, text.Location.Y + 25); connectionLine.SetSpecifics(line); connectionLine.ObjectColor = Color.LightGray; } }
public void Execute(IPCBIWindow parent) { IStep step = parent.GetCurrentStep(); IODBLayer layer = (IODBLayer)step.GetLayer("top"); IFilter filter = new IFilter(parent); // Pins foreach (ICMPObject cmp in step.GetAllCMPObjects()) { foreach (IPin pin in cmp.GetPinList()) { IODBObject outlinePolygon = filter.CreatePolygon(layer); ISurfaceSpecifics specOutline = (ISurfaceSpecifics)outlinePolygon.GetSpecifics(); bool polyStart = true; PointF StartPoint = new PointF(0, 0); PointF EndPoint = new PointF(0, 0); foreach (IEdge edge in pin.GetPolygonOutline(cmp).GetEdges()) { if (polyStart) { polyStart = false; StartPoint = new PointF((float)edge.Begin.X, (float)edge.Begin.Y); specOutline.StartPolygon(false, StartPoint); if (edge is IArcEdge) { IArcEdge aEdge = (IArcEdge)edge; PointF start = new PointF((float)aEdge.Begin.X, (float)aEdge.Begin.Y); PointF end = new PointF((float)aEdge.End.X, (float)aEdge.End.Y); PointF center = new PointF((float)aEdge.Center.X, (float)aEdge.Center.Y); specOutline.AddArc(start, end, center, aEdge.ClockWise); if (aEdge.ClockWise) { EndPoint = end; } else { EndPoint = start; } } else if (edge is ILineEdge) { ILineEdge aEdge = (ILineEdge)edge; PointF start = new PointF((float)aEdge.Begin.X, (float)aEdge.Begin.Y); PointF end = new PointF((float)aEdge.End.X, (float)aEdge.End.Y); specOutline.AddLine(start, end); EndPoint = end; } } else if (edge is IArcEdge) { IArcEdge aEdge = (IArcEdge)edge; PointF start = new PointF((float)aEdge.Begin.X, (float)aEdge.Begin.Y); PointF end = new PointF((float)aEdge.End.X, (float)aEdge.End.Y); PointF center = new PointF((float)aEdge.Center.X, (float)aEdge.Center.Y); specOutline.AddArc(start, end, center, aEdge.ClockWise); if (aEdge.ClockWise) { EndPoint = end; } else { EndPoint = start; } } else if (edge is ILineEdge) { ILineEdge aEdge = (ILineEdge)edge; PointF start = new PointF((float)aEdge.Begin.X, (float)aEdge.Begin.Y); PointF end = new PointF((float)aEdge.End.X, (float)aEdge.End.Y); specOutline.AddLine(start, end); EndPoint = end; } } //specOutline.AddLine(EndPoint, StartPoint); specOutline.EndPolygon(); //close the new contour outlinePolygon.SetSpecifics(specOutline); } } parent.UpdateView(); }
public void Execute(IPCBIWindow parent) { string PackageName = "TESTPUNKT"; bool topSide = true; bool useFlattenStep = true; if (!parent.JobIsLoaded) { return; } IFilter filter = new IFilter(parent); IStep step = parent.GetCurrentStep(); IMatrix matrix = parent.GetMatrix(); if (matrix == null) { return; } step.TurnOffAllLayer(); step.ClearSelection(); //nicht für flatten step, da durch Threads zu langsam und dann evtl die neuen Daten wieder gelöscht werden! if (!useFlattenStep) { matrix.DelateLayer("testpoint_locations_top", false); matrix.DelateLayer("testpoint_locations_bot", false); } if (topSide) { CreateForOneSide(true, step, filter, PackageName, matrix.GetAllDrillLayersForThisLayer(matrix.GetTopSignalLayer())); } else { CreateForOneSide(false, step, filter, PackageName, matrix.GetAllDrillLayersForThisLayer(matrix.GetBotSignalLayer())); } //gitter 500x500 IODBLayer rasterLayer = filter.CreateEmptyODBLayer("raster", step.Name); int shapeIndex = IFilter.AddToolDefinitionRound(rasterLayer, 10); RectangleF boundsStep = step.GetBounds(); int countYLines = (int)(boundsStep.Height / 500) + 1; int countXLines = (int)(boundsStep.Width / 500) + 1; for (int y = 0; y <= countYLines; y++) { for (int x = 0; x <= countXLines; x++) { for (int i = 0; i < 5; i++) //5 sublines { int yVal = y * 500; int xVal = x * 500; if (x < countXLines) { CreateHorLine(filter, rasterLayer, shapeIndex, yVal, xVal + i * 100 + 25); } if (y < countYLines) { CreateVertLine(filter, rasterLayer, shapeIndex, yVal + i * 100 + 25, xVal); } } } } for (int y = 0; y < countYLines; y++) { #region draw text IODBObject textForPad = filter.CreateText(rasterLayer); ITextSpecificsD text = (ITextSpecificsD)textForPad.GetSpecificsD(); text.Text = "Y" + (y + 1); text.TextSize = new SizeF(50, 80); text.Location = new PCBI.MathUtils.PointD(-120, y * 500 + 200); text.WidthFactor = 1; textForPad.SetSpecifics(text); //right side IODBObject textForPad2 = filter.CreateText(rasterLayer); ITextSpecificsD text2 = (ITextSpecificsD)textForPad.GetSpecificsD(); text2.Text = text.Text; text2.TextSize = new SizeF(50, 80); text2.Location = new PCBI.MathUtils.PointD(countXLines * 500 + 120, y * 500 + 200); text2.WidthFactor = 1; textForPad2.SetSpecifics(text2); } for (int x = 0; x < countXLines; x++) { IODBObject textForPad = filter.CreateText(rasterLayer); ITextSpecificsD text = (ITextSpecificsD)textForPad.GetSpecificsD(); text.Text = "X" + (x + 1); text.TextSize = new SizeF(50, 80); text.Location = new PCBI.MathUtils.PointD(x * 500 + 200, -100); text.Rotation = -90; text.WidthFactor = 1; textForPad.SetSpecifics(text); //top side IODBObject textForPad2 = filter.CreateText(rasterLayer); ITextSpecificsD text2 = (ITextSpecificsD)textForPad.GetSpecificsD(); text2.Text = text.Text; text2.TextSize = new SizeF(50, 80); text2.Location = new PCBI.MathUtils.PointD(x * 500 + 300, countYLines * 500 + 100); text2.Rotation = 90; text2.WidthFactor = 1; textForPad2.SetSpecifics(text2); #endregion } foreach (string drillName in matrix.GetAllDrillLayerNames()) { IODBLayer drillLayer = (IODBLayer)step.GetLayer(drillName); foreach (IODBObject drill in drillLayer.GetAllLayerObjects()) { Dictionary <PCBI.FeatureAttributeEnum, string> attribs = drill.GetAttributesDictionary(); if (drill.Type == IObjectType.Pad && attribs.ContainsKey(PCBI.FeatureAttributeEnum.drill) && attribs.ContainsKey(PCBI.FeatureAttributeEnum.geometry)) { if (attribs[PCBI.FeatureAttributeEnum.drill].ToUpperInvariant() == "NON_PLATED" && attribs[PCBI.FeatureAttributeEnum.geometry].ToUpperInvariant() == "ICTAUFNAHME") { IODBObject drillMarker = filter.CreatePad(rasterLayer); IPadSpecificsD drillSpec = (IPadSpecificsD)drill.GetSpecificsD(); int shapeIndexNew = IFilter.AddToolDefinitionRound(rasterLayer, (float)drillSpec.Diameter); drillSpec.ShapeIndex = shapeIndexNew; drillMarker.SetSpecifics(drillSpec); } } } } matrix.UpdateDataAndList(); if (!useFlattenStep) { parent.UIAction.Execute(ID_ActionItem.ID_PRINT_PREVIEW); } }
public void Execute(IPCBIWindow parent) { //this script replace mini arcs by lines try { IStep step = parent.GetCurrentStep(); if (step == null) { return; } double minLenghtArcToReplaceByLine = IMath.MM2Mils(0.02); //20?m maximum for arcs IFilter objectCreator = new IFilter(parent); foreach (string layerName in step.GetAllLayerNames()) //check all layer { ILayer gerberLayer = step.GetLayer(layerName); if (gerberLayer == null) { continue; } if (gerberLayer is ICMPLayer) { continue; //should not be for gerberlayers } if (gerberLayer is IPictureLayer) { continue; //should not be for gerberlayers } //gerber layers always contain IODBObjects foreach (IODBObject obj in gerberLayer.GetAllLayerObjects()) { if (obj.Type == IObjectType.Arc) { #region one arc IArcSpecificsD arc = (IArcSpecificsD)obj.GetSpecificsD(); double radius = IMath.DistancePointToPoint(arc.Start, arc.Center); double angle = IMath.GetAngle(arc.Start, arc.End, arc.Center, arc.ClockWise); //always >=0 if (angle > 0) //ODB++ spec define arcs with Start == End as full circles (angle = 0 in this calculation) { double bogen = 2 * Math.PI * radius * angle / 360; if (bogen < minLenghtArcToReplaceByLine && arc.PenWidth > bogen)//simple condition to identify mini arcs { //replace by line IODBObject lineObj = objectCreator.CreateLine((IODBLayer)gerberLayer); //we know it's a gerber layer -> it must be a IODBLayer lineObj.SetSpecifics(new ILineSpecificsD() { Start = arc.Start, End = arc.End, ShapeIndex = arc.ShapeIndex, Positive = arc.Positive }); if (!obj.ReplaceItemBy(lineObj)) //replace it { Console.WriteLine("Could not replace item!"); } } } #endregion } } } } catch (Exception ex) { Console.WriteLine("Error! " + ex.ToString()); } parent.UpdateView(); //to show the replaced elements }
public void Execute(IPCBIWindow parent) { double sizeRouting = PCBI.MathUtils.IMath.MM2Mils(2); //2 mm double sizeCutout = PCBI.MathUtils.IMath.MM2Mils(2); //2 mm double spaceCutout = PCBI.MathUtils.IMath.MM2Mils(100); //100 mm double lengthCutout = PCBI.MathUtils.IMath.MM2Mils(5); //5 mm double sumUpLength = 0; //offset for start IStep step = parent.GetCurrentStep(); if (step == null) { return; } PCBI.MathUtils.IPolyClass polyOfOutline = step.GetPCBOutlinePoly(); if (polyOfOutline.GetEdgeCount() == 0) { return; } IFilter filter = new IFilter(parent); IODBLayer HelperLayer = filter.CreateEmptyODBLayer("rout_outline_helper", step.Name); //this helper layer contains the uncutted line elements IODBLayer outlineLayerRouting = filter.CreateEmptyODBLayer("rout_outline", step.Name); IODBLayer cutoutLayerRouting = filter.CreateEmptyODBLayer("rout_cutout", step.Name); #region clean layers for multi use List <IODBObject> objListToRemove = new List <IODBObject>(); foreach (IODBObject obj in HelperLayer.GetAllLayerObjects()) { objListToRemove.Add(obj); } HelperLayer.RemoveObjects(objListToRemove); objListToRemove = new List <IODBObject>(); foreach (IODBObject obj in cutoutLayerRouting.GetAllLayerObjects()) { objListToRemove.Add(obj); } cutoutLayerRouting.RemoveObjects(objListToRemove); objListToRemove = new List <IODBObject>(); foreach (IODBObject obj in outlineLayerRouting.GetAllLayerObjects()) { objListToRemove.Add(obj); } outlineLayerRouting.RemoveObjects(objListToRemove); #endregion int shapeIndexOutlinediameter = IFilter.AddToolDefinitionRound(HelperLayer, (float)sizeRouting); foreach (PCBI.MathUtils.IEdge edge in polyOfOutline.GetEdges()) { #region outline elements if (edge.Type == IEdgeType.Arc) { IODBObject newArc = filter.CreateArc(HelperLayer); IArcSpecificsD arc = (IArcSpecificsD)newArc.GetSpecificsD(); arc.ClockWise = ((IArcEdge)edge).ClockWise; if (arc.ClockWise) { arc.Start = edge.Begin; arc.End = edge.End; } else { arc.End = edge.Begin; arc.Start = edge.End; } arc.Center = ((PCBI.MathUtils.IArcEdge)edge).Center; arc.ShapeIndex = shapeIndexOutlinediameter; newArc.SetSpecifics(arc); } else { IODBObject newLine = filter.CreateLine(HelperLayer); ILineSpecificsD line = (ILineSpecificsD)newLine.GetSpecificsD(); line.Start = edge.Begin; line.End = edge.End; line.ShapeIndex = shapeIndexOutlinediameter; newLine.SetSpecifics(line); } #endregion } //make one surface of all lines and arcs HelperLayer.CreateLayerNetList(true); HelperLayer.PolygonizeLayer(0, false); PointD lastPToIdentifyHole = PointD.InfPoint; foreach (IODBObject surface in HelperLayer.GetAllLayerObjects()) { #region replace surfaces by routing lines and arcs if (surface.Type != IObjectType.Surface) { continue; } objListToRemove.Add(surface); List <ISurfaceSpecificsD> isle = ((ISurfaceSpecificsD)surface.GetSpecificsD()).SplitInIsleAndHoles(parent); if (isle.Count > 0) { for (int i = 0; i < isle.Count; i++) { bool foundelement = false; foreach (IODBObject linesAndArcs in isle[i].GetOutline()) { if (linesAndArcs.Type == IObjectType.Arc) { #region arc IODBObject newArc = filter.CreateArc(HelperLayer); IArcSpecificsD arc = (IArcSpecificsD)linesAndArcs.GetSpecificsD(); if (lastPToIdentifyHole == PointD.InfPoint || !(lastPToIdentifyHole != arc.Start && lastPToIdentifyHole != arc.End)) { lastPToIdentifyHole = arc.End; } else { break; } newArc.SetSpecifics(arc); #endregion } else { #region line IODBObject newLine = filter.CreateLine(HelperLayer); ILineSpecificsD line = (ILineSpecificsD)linesAndArcs.GetSpecificsD(); if (lastPToIdentifyHole == PointD.InfPoint || line.Start == lastPToIdentifyHole) { lastPToIdentifyHole = line.End; } else { break; } newLine.SetSpecifics(line); #endregion } foundelement = true; } if (foundelement) { break; } } } #endregion } HelperLayer.RemoveObjects(objListToRemove); //surface remove int shapeIndexCutoutdiameter = IFilter.AddToolDefinitionRound(outlineLayerRouting, (float)sizeCutout); int shapeIndexCutoutdiameter2 = IFilter.AddToolDefinitionRound(cutoutLayerRouting, (float)sizeCutout); double sumUpGap = 0; foreach (IODBObject lineOrArc in HelperLayer.GetAllLayerObjects()) { if (lineOrArc.Type == IObjectType.Line) { #region lines ILineSpecificsD line = (ILineSpecificsD)lineOrArc.GetSpecificsD(); double length = IMath.DistancePointToPoint(line.Start, line.End); double lengthComplete = length; while (true) { if (length <= lengthCutout) { #region short lines sumUpLength += lengthCutout; if (sumUpLength > spaceCutout) { sumUpGap += lengthCutout; IODBObject lineObj = filter.CreateLine(cutoutLayerRouting); ILineSpecificsD lineSub = (ILineSpecificsD)lineOrArc.GetSpecificsD(); lineSub.ShapeIndex = shapeIndexCutoutdiameter2; lineSub.Start = IMath.GetPointOnLine(line.Start, line.End, lengthComplete - length); length = 0; lineSub.End = IMath.GetPointOnLine(line.Start, line.End, lengthComplete - length); lineObj.SetSpecifics(lineSub); if (sumUpGap > lengthCutout) { sumUpGap = 0; sumUpLength = 0; } IAttributeElement attribRoutningComp = new IAttributeElement(PCBI.FeatureAttributeEnum.comp); attribRoutningComp.Value = "none"; IAttribute.SetAttribute(attribRoutningComp, lineObj); } else { IODBObject lineObj = filter.CreateLine(outlineLayerRouting); ILineSpecificsD lineSub = (ILineSpecificsD)lineOrArc.GetSpecificsD(); lineSub.ShapeIndex = shapeIndexCutoutdiameter; lineSub.Start = IMath.GetPointOnLine(line.Start, line.End, lengthComplete - length); length = 0; lineSub.End = IMath.GetPointOnLine(line.Start, line.End, lengthComplete - length); lineObj.SetSpecifics(lineSub); IAttributeElement attribRoutningComp = new IAttributeElement(PCBI.FeatureAttributeEnum.comp); attribRoutningComp.Value = "none"; IAttribute.SetAttribute(attribRoutningComp, lineObj); } break; #endregion } else { #region long lines sumUpLength += lengthCutout; if (sumUpLength > spaceCutout || sumUpGap > 0) { sumUpGap += lengthCutout; IODBObject lineObj = filter.CreateLine(cutoutLayerRouting); ILineSpecificsD lineSub = (ILineSpecificsD)lineOrArc.GetSpecificsD(); lineSub.ShapeIndex = shapeIndexCutoutdiameter2; lineSub.Start = IMath.GetPointOnLine(line.Start, line.End, lengthComplete - length); length -= lengthCutout; lineSub.End = IMath.GetPointOnLine(line.Start, line.End, lengthComplete - length); lineObj.SetSpecifics(lineSub); if (sumUpGap > lengthCutout) { sumUpGap = 0; sumUpLength = 0; } IAttributeElement attribRoutningComp = new IAttributeElement(PCBI.FeatureAttributeEnum.comp); attribRoutningComp.Value = "none"; IAttribute.SetAttribute(attribRoutningComp, lineObj); } else { IODBObject lineObj = filter.CreateLine(outlineLayerRouting); ILineSpecificsD lineSub = (ILineSpecificsD)lineOrArc.GetSpecificsD(); lineSub.ShapeIndex = shapeIndexCutoutdiameter; lineSub.Start = IMath.GetPointOnLine(line.Start, line.End, lengthComplete - length); length -= lengthCutout; lineSub.End = IMath.GetPointOnLine(line.Start, line.End, lengthComplete - length); lineObj.SetSpecifics(lineSub); IAttributeElement attribRoutningComp = new IAttributeElement(PCBI.FeatureAttributeEnum.comp); attribRoutningComp.Value = "none"; IAttribute.SetAttribute(attribRoutningComp, lineObj); } #endregion } } #endregion } else if (lineOrArc.Type == IObjectType.Arc) { #region arcs IArcSpecificsD arc = (IArcSpecificsD)lineOrArc.GetSpecificsD(); double arcLength = IMath.DistancePointToPoint(arc.Start, arc.End); sumUpLength += arcLength; if (sumUpLength > spaceCutout || sumUpGap > 0) { sumUpGap += arcLength; IODBObject arcObj = filter.CreateArc(cutoutLayerRouting); arc.ShapeIndex = shapeIndexCutoutdiameter2; arcObj.SetSpecifics(arc); if (sumUpGap > lengthCutout) { sumUpGap = 0; sumUpLength = 0; } IAttributeElement attribRoutningComp = new IAttributeElement(PCBI.FeatureAttributeEnum.comp); attribRoutningComp.Value = "none"; IAttribute.SetAttribute(attribRoutningComp, arcObj); } else { IODBObject arcObj = filter.CreateArc(outlineLayerRouting); arc.ShapeIndex = shapeIndexCutoutdiameter; arcObj.SetSpecifics(arc); IAttributeElement attribRoutningComp = new IAttributeElement(PCBI.FeatureAttributeEnum.comp); attribRoutningComp.Value = "none"; IAttribute.SetAttribute(attribRoutningComp, arcObj); } #endregion } } //additional attributes are .feed, .speed, .rout_flag, .comp. and .rout_chain IMatrix matrix = parent.GetMatrix(); if (matrix != null) { matrix.UpdateDataAndList(); } parent.UpdateView(); }