public override string ToString()
{
// for some reason the arc in version 5.99 needs start middle end
// rather than start end angle like for fp_arc ... go figure
// X1, Y1 = centre
double Xs, Ys, Xm, Ym, Xe, Ye;
Xs = Math.Round(X1 + Radius * Math.Cos(Radians(StartAngle)), Precision);
Ys = Math.Round(Y1 + Radius * Math.Sin(Radians(StartAngle)), Precision);
Xm = Math.Round(X1 + Radius * Math.Cos(Radians(StartAngle + (EndAngle - StartAngle) / 2)), Precision);
Ym = Math.Round(Y1 + Radius * Math.Sin(Radians(StartAngle + (EndAngle - StartAngle) / 2)), Precision);
Xe = Math.Round(X1 + Radius * Math.Cos(Radians(EndAngle)), Precision);
Ye = Math.Round(Y1 + Radius * Math.Sin(Radians(EndAngle)), Precision);
string netstr = (net == -1) ? "" : $"(net {net})";
if (Brd.IsCopperLayer(Layer))
{
return($" (arc (start {Xs} {-Ys}) (mid {Xm} {-Ym}) (end {Xe} {-Ye}) (layer {Brd.GetLayer(Layer)}) {netstr} (width {Width}))\n");
}
else
{
return($" (gr_arc (start {Math.Round(X1, Precision)} {Math.Round(-Y1, Precision)}) (end {Math.Round(Xs, Precision)} {Math.Round(-Ys, Precision)}) (angle {Math.Round(-(EndAngle - StartAngle), Precision)}) (layer {Brd.GetLayer(Layer)}) (width {Width}))\n");
}
}
public void ValidadeDestinationPosition(Position origin, Position destination)
{
if (!Brd.Piece(origin).PossibleMovement(destination))
{
throw new BoardException("Invalid destination position!");
}
}
public string ToString(double x, double y)
{
Int32 SA = Convert.ToInt32(StartAngle * 100);
Int32 EA = Convert.ToInt32(EndAngle * 100);
if (Math.Abs(EA - SA) == 36000)
{
// it's a circle
return($" (fp_circle (center {Math.Round(X1 - x, Precision)} {Math.Round(-(Y1 - y), Precision)}) (end {Math.Round(X1+Radius - x, Precision)} {Math.Round(-(Y1 - y), Precision)}) (layer {Layer}) (width {Width}))\n");
}
else
{
double Xs, Ys, Xe, Ye;
Xs = Math.Round((X1 - x) + Radius * Math.Cos(Radians(StartAngle)), Precision);
Ys = Math.Round((Y1 - y) + Radius * Math.Sin(Radians(StartAngle)), Precision);
Xe = Math.Round((X1 - x) + Radius * Math.Cos(Radians(EndAngle)), Precision);
Ye = Math.Round((Y1 - y) + Radius * Math.Sin(Radians(EndAngle)), Precision);
Width = Math.Round(Width, Precision);
CheckMinMax(Xs, Ys);
CheckMinMax(Xe, Xe);
var arc = new StringBuilder("");
string n = (net == -1) ? "" : $"net {net}";
List <string> Layers = Brd.GetLayers(Brd.GetLayer(Layer));
foreach (var L in Layers)
{
arc.Append($" (arc (start {Xs} {-Ys}) (end {Xe} {Ye}) (angle {Math.Round(EndAngle-StartAngle, Precision)}) (layer {L}) (width {Width}))\n");
}
return(arc.ToString());
}
}
public override string ToString()
{
string StartL = Brd.GetLayer(StartLayer);
string EndL = Brd.GetLayer(EndLayer);
string blind = ((StartL != "F.Cu") || (EndL != "B.Cu")) ? "blind" : "";
return($" (via {blind} (at {Math.Round(X, Precision)} {Math.Round(-Y, Precision)}) (size {Size}) (drill {Drill}) (layers {StartL} {EndL}) (net {Net}))\n");
}
public override bool[,] PossibleMovements()
{
bool[,] mat = new bool[Brd.Rows, Brd.Columns];
Position pos = new Position(0, 0);
pos.SetValues(Position.Row - 1, Position.Column - 2);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row - 2, Position.Column - 1);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row - 2, Position.Column + 1);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row - 1, Position.Column + 2);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row + 1, Position.Column + 2);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row + 2, Position.Column + 1);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row + 2, Position.Column - 1);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row + 1, Position.Column - 2);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
return(mat);
}
public void MakeThePlay(Position origin, Position destination)
{
Piece CapturedPiece = RunMovement(origin, destination);
if (IsItChecked(CurrentPlayer))
{
UndoMovement(origin, destination, CapturedPiece);
throw new BoardException("You Can't put yourself in check!");
}
Piece p = Brd.Piece(destination);
//#Special Play: Promotion
if (p is Pawn)
{
if (p.Color == Color.White && destination.Row == 0 || p.Color == Color.Black && destination.Row == 7)
{
p = Brd.RemovePiece(destination);
Pieces.Remove(p);
Piece queen = new Queen(Brd, p.Color);
Brd.PutPiece(queen, destination);
Pieces.Add(queen);
}
}
if (IsItChecked(Opponent(CurrentPlayer)))
{
Check = true;
}
else
{
Check = false;
}
if (CheckmateTest(Opponent(CurrentPlayer)))
{
Finished = true;
}
else
{
Turn++;
ChangePlayer();
}
//#Special Play: En Passant
if (p is Pawn && destination.Row == origin.Row - 2 || destination.Row == origin.Row + 2)
{
VulnerableEnPassant = p;
}
else
{
VulnerableEnPassant = null;
}
}
public override bool[,] PossibleMovements()
{
bool[,] mat = new bool[Brd.Rows, Brd.Columns];
Position pos = new Position(0, 0);
//North
pos.SetValues(Position.Row - 1, Position.Column);
while (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
if (Brd.Piece(pos) != null && Brd.Piece(pos).Color != Color)
{
break;
}
pos.SetValues(pos.Row - 1, pos.Column);
}
//South
pos.SetValues(Position.Row + 1, Position.Column);
while (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
if (Brd.Piece(pos) != null && Brd.Piece(pos).Color != Color)
{
break;
}
pos.SetValues(pos.Row + 1, pos.Column);
}
//East
pos.SetValues(Position.Row, Position.Column + 1);
while (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
if (Brd.Piece(pos) != null && Brd.Piece(pos).Color != Color)
{
break;
}
pos.SetValues(pos.Row, pos.Column + 1);
}
//West
pos.SetValues(Position.Row, Position.Column - 1);
while (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
if (Brd.Piece(pos) != null && Brd.Piece(pos).Color != Color)
{
break;
}
pos.SetValues(pos.Row, pos.Column - 1);
}
return(mat);
}
public Piece RunMovement(Position origin, Position destination)
{
Piece P = Brd.RemovePiece(origin);
P.IncreaseMovementsQty();
Piece CapturedPiece = Brd.RemovePiece(destination);
Brd.PutPiece(P, destination);
if (CapturedPiece != null)
{
Captured.Add(CapturedPiece);
}
//#Special Play: Castling short
if (P is King && destination.Column == origin.Column + 2)
{
Position originR = new Position(origin.Row, origin.Column + 3);
Position destinationR = new Position(origin.Row, origin.Column + 1);
Piece R = Brd.RemovePiece(originR);
R.IncreaseMovementsQty();
Brd.PutPiece(R, destinationR);
}
//#Special Play: Castling long
if (P is King && destination.Column == origin.Column - 2)
{
Position originR = new Position(origin.Row, origin.Column - 4);
Position destinationR = new Position(origin.Row, origin.Column - 1);
Piece R = Brd.RemovePiece(originR);
R.IncreaseMovementsQty();
Brd.PutPiece(R, destinationR);
}
//#Special Play: En Passant
if (P is Pawn)
{
if (origin.Column != destination.Column && CapturedPiece == null)
{
Position posP;
if (P.Color == Color.White)
{
posP = new Position(destination.Row + 1, destination.Column);
}
else
{
posP = new Position(destination.Row - 1, destination.Column);
}
CapturedPiece = Brd.RemovePiece(posP);
Captured.Add(CapturedPiece);
}
}
return(CapturedPiece);
}
public void UndoMovement(Position origin, Position destination, Piece capturedPiece)
{
Piece P = Brd.RemovePiece(destination);
P.DecreaseMovementsQty();
if (capturedPiece != null)
{
Brd.PutPiece(capturedPiece, destination);
Captured.Remove(capturedPiece);
}
Brd.PutPiece(P, origin);
//#Special Play: Castling short
if (P is King && destination.Column == origin.Column + 2)
{
Position originR = new Position(origin.Row, origin.Column + 3);
Position destinationR = new Position(origin.Row, origin.Column + 1);
Piece R = Brd.RemovePiece(destinationR);
R.DecreaseMovementsQty();
Brd.PutPiece(R, originR);
}
//#Special Play: Castling long
if (P is King && destination.Column == origin.Column - 2)
{
Position originR = new Position(origin.Row, origin.Column - 4);
Position destinationR = new Position(origin.Row, origin.Column - 1);
Piece R = Brd.RemovePiece(destinationR);
R.DecreaseMovementsQty();
Brd.PutPiece(R, originR);
}
//#Special Play: En Passant
if (P is Pawn)
{
if (origin.Column != destination.Column && capturedPiece == VulnerableEnPassant)
{
Piece pawn = Brd.RemovePiece(destination);
Position posP;
if (P.Color == Color.White)
{
posP = new Position(3, destination.Column);
}
else
{
posP = new Position(4, destination.Column);
}
Brd.PutPiece(pawn, posP);
}
}
}
public void ValidateOriginPosition(Position pos)
{
if (Brd.Piece(pos) == null)
{
throw new BoardException("There is no piece in the chosen origin position!");
}
if (CurrentPlayer != Brd.Piece(pos).Color)
{
throw new BoardException("The chosen piece is not yours!");
}
if (!Brd.Piece(pos).IsTherePossibleMovements())
{
throw new BoardException("There is no possible movements for the chosen piece!");
}
}
public override string ToString()
{
var ret = new StringBuilder("");
string connectstyle = "";
double clearance = GetRuleValue(this, "Clearance", "PolygonClearance");
if (Layer.Substring(0, 2) == "In")
{
// this is an inner layer so use plane clearance
clearance = GetRuleValue(this, "PlaneClearance", "PlaneClearance");
}
List <string> Layers = Brd.GetLayers(Brd.GetLayer(Layer));
foreach (var L in Layers)
{
ret.Append($" (zone (net {NetNo}) (net_name {NetName}) (layer {L}) (hatch edge 0.508)");
ret.Append($" (priority {GetPriority(PourIndex)})\n");
ret.Append($" (connect_pads {connectstyle} (clearance {clearance}))\n"); // TODO sort out these numbers properly
ret.Append($" (min_thickness {NeckWidthThreshold})\n");
ret.Append(" (fill yes (arc_segments 16) (thermal_gap 0.2) (thermal_bridge_width 0.3))\n");
var i = 0;
ret.Append(" (polygon (pts\n ");
foreach (var Point in Points)
{
i++;
if ((i % 5) == 0)
{
ret.Append("\n ");
}
ret.Append(Point.ToString());
CheckMinMax(Point.X, Point.Y);
}
ret.Append("\n )\n )\n )\n");
if (IsSplitPlane)
{
ret.Append("# Split Plane\n");
}
}
return(ret.ToString());
}
public override string ToString(double x, double y, double ModuleRotation)
{
Point2D p1 = new Point2D(X1 - x, Y1 - y);
double X2 = (X1 - x) + Radius * Math.Cos(Radians(StartAngle));
double Y2 = (Y1 - y) + Radius * Math.Sin(Radians(StartAngle));
Point2D p2 = new Point2D(X2, Y2);
p1.Rotate(ModuleRotation);
p2.Rotate(ModuleRotation);
Int32 SA = Convert.ToInt32(StartAngle * 100);
Int32 EA = Convert.ToInt32(EndAngle * 100);
if (Math.Abs(EA - SA) == 36000)
{
// it's a circle
StringBuilder circle = new StringBuilder("");
List <string> Layers = Brd.GetLayers(Brd.GetLayer(Layer));
foreach (var L in Layers)
{
circle.Append($" (fp_circle (center {p1.X} {-p1.Y}) (end {p2.X} {-p2.Y}) (layer {L}) (width {Width}))\n");
}
return(circle.ToString());
}
else
{
StringBuilder arc = new StringBuilder("");
List <string> Layers = Brd.GetLayers(Brd.GetLayer(Layer));
foreach (var L in Layers)
{
arc.Append($" (fp_arc (start {Math.Round(p1.X, Precision)} {Math.Round(-p1.Y, Precision)}) (end {Math.Round(p2.X, Precision)} {Math.Round(-p2.Y, Precision)}) (angle {Math.Round(-(EndAngle - StartAngle), Precision)}) (layer {L}) (width {Width}))\n");
}
return(arc.ToString());;
}
}
public override bool ProcessLine(byte[] line)
{
double StartAngle, EndAngle, Radius, Width;
Layers Layer;
double X1, Y1;
Int16 Component;
Int16 net;
base.ProcessLine();
ArcStruct a = ByteArrayToStructure <ArcStruct>(line);
Layer = (Layers)a.Layer;
net = a.net;
net++;
Component = a.Component;
X1 = Math.Round((double)a.X1 * 25.4 / 10000000 - originX, Precision);
Y1 = Math.Round((double)a.Y1 * 25.4 / 10000000 - originY, Precision);
Radius = Math.Round((double)a.Radius * 25.4 / 10000000, Precision);
StartAngle = a.StartAngle;
EndAngle = a.EndAngle;
Width = (double)a.Width * 25.4 / 10000000;
bool InComponent = Component != -1;
double Angle;
if (EndAngle < StartAngle)
{
EndAngle += 360;
}
Angle = (EndAngle - StartAngle);
double X = X1 + Radius * Math.Cos(StartAngle * Math.PI / 180);
double Y = Y1 + Radius * Math.Sin(StartAngle * Math.PI / 180);
string layer = Brd.GetLayer(Layer);
if (!InComponent)
{
if (net > 0 && Brd.IsCopperLayer(Layer))
{
if (!Globals.PcbnewVersion)
{
// arcs with nets on copper layers allowed in 5.99
Arc Arc = new Arc(X1, Y1, StartAngle, EndAngle, Radius, Layer, Width, net);
ArcsL.Add(Arc);
}
else
{
//arcs.Append($" (arc (start {Math.Round(X1, Precision)} {Math.Round(-Y1, Precision)}) (end {Math.Round(X, Precision)} {Math.Round(-Y, Precision)}) (angle {Math.Round(Angle, Precision)}) (layer {L}) (net {Net}) (width {Width}))\n");
// we have an arc/track on a copper layer and it has a net
// these aren't supported by KiCad yet so generate a curve out of track segments
// first normalise it so that the centre is at 0,0
// save the centre point
double XC = X1;
double YC = Y1;
X = X - XC;
Y = Y - YC;
double radius = Math.Sqrt(X * X + Y * Y);
// start angle in radians
double start_angle = Arc.Radians(StartAngle);
double end_angle = Arc.Radians(EndAngle);
double X2 = Radius * Math.Cos(end_angle);
double Y2 = Radius * Math.Sin(end_angle);
X = Radius * Math.Cos(start_angle);
Y = Radius * Math.Sin(start_angle);
// generate arc segments at 5° increments
for (double angle = start_angle; angle < end_angle; angle += 2 * Math.PI / 72)
{
X1 = Radius * Math.Cos(angle);
Y1 = Radius * Math.Sin(angle);
Line Line = new Line(XC + X, YC + Y, XC + X1, YC + Y1, layer, Width, net);
LinesL.Add(Line);
X = X1;
Y = Y1;
}
// do last segment
if (X != X2 || Y != Y2)
{
Line Line = new Line(X + XC, Y + YC, X2 + XC, Y2 + YC, layer, Width, net);
LinesL.Add(Line);
}
}
}
else
{
// only add if not part of board outline
if ((layer != "Edge.Cuts") || !Brd.CheckExistingArc(X1, Y1, X, Y, Angle))
{
List <string> Layers = Brd.GetLayers(layer);
foreach (var L in Layers)
{
Arc Arc = new Arc(X1, Y1, StartAngle, EndAngle, Radius, Brd.GetAltiumLayer(L), Width);
ArcsL.Add(Arc);
}
}
}
}
else
{
Arc Arc = new Arc(X1, Y1, StartAngle, EndAngle, Radius, Layer, Width);
ModulesL[Component].Arcs.Add(Arc);
}
return(true);
}
public Module(string line)
{
string param;
ObjectType = PCBObjectType.Module;
Designator = "";
Comment = "";
Name = GetString(line, "|PATTERN=");
ComponentKind = GetString(line, "|COMPONENTKIND=");
if (Name.Contains("\\"))
{
Name = Name.Replace("\\", "_"); // TODO check this out
}
if (Name.Contains("\""))
{
Name = Name.Replace("\"", "_");
}
if ((param = GetString(line, "|X=").Trim(charsToTrim)) != "")
{
X = GetCoordinateX(param);
}
if ((param = GetString(line, "|Y=").Trim(charsToTrim)) != "")
{
Y = GetCoordinateY(param);
}
Layer = "";
if ((param = GetString(line, "|LAYER=")) != "")
{
Layer = Brd.GetLayer(param);
}
DesignatorOn = true;
if ((param = GetString(line, "|NAMEON=")) != "")
{
DesignatorOn = param == "TRUE";
}
CommentOn = true;
if ((param = GetString(line, "|COMMENTON=")) != "")
{
CommentOn = param == "TRUE";
}
Locked = false;
if ((param = GetString(line, "|LOCKED=")) != "")
{
Locked = param == "TRUE";
}
PrimitiveLock = false;
if ((param = GetString(line, "|PRIMITIVELOCK=")) != "")
{
PrimitiveLock = param == "TRUE";
}
Rotation = 0;
if ((param = GetString(line, "|ROTATION=").Trim(charsToTrim)) != "")
{
Rotation = Convert.ToDouble(param);
if (Rotation == 360)
{
Rotation = 0;
}
}
if (Layer == "F.Cu" || Layer == "B.Cu")
{
Attr = "smd";
}
else
{
Attr = "";
}
if (ComponentKind == "1" || ComponentKind == "2" || ComponentKind == "4")
{
Attr = "virtual";
}
Tedit = "(tedit 0)";
Tstamp = "(tstamp 0)";
// create the object lists for this component
Lines = new ObjectList <Line>();
Pads = new ObjectList <Pad>();
Strings = new ObjectList <String>();
ViasL = new ObjectList <Via>();
Arcs = new ObjectList <Arc>();
Fills = new ObjectList <Fill>();
Polygons = new ObjectList <Polygon>();
Regions = new ObjectList <Region>();
ComponentBodies = new ObjectList <ComponentBody>();
ShapeBasedModels = new ObjectList <ShapeBasedModel>();
ID++; // update for next Module
}
public Dimension(string line)
{
string[] words = line.Split('|');
string param;
ObjectType = PCBObjectType.Dimension;
if ((param = GetString(line, "|X1=").Trim(charsToTrim)) != "")
{
X1 = GetCoordinateX(param);
}
if ((param = GetString(line, "|Y1=").Trim(charsToTrim)) != "")
{
Y1 = GetCoordinateY(param);
}
if ((param = GetString(line, "|X2=").Trim(charsToTrim)) != "")
{
X2 = GetCoordinateX(param);
}
if ((param = GetString(line, "|Y2=").Trim(charsToTrim)) != "")
{
Y2 = GetCoordinateY(param);
}
if ((param = GetString(line, "|DIMENSIONKIND=")) != "")
{
DIMENSIONKIND = Convert.ToInt16(param);
}
if ((param = GetString(line, "|DIMENSIONLAYER=")) != "")
{
layer = Brd.GetLayer(param);
}
if ((param = GetString(line, "|LX=").Trim(charsToTrim)) != "")
{
LX = GetCoordinateX(param);
}
if ((param = GetString(line, "|LY=").Trim(charsToTrim)) != "")
{
LY = GetCoordinateY(param);
}
if ((param = GetString(line, "|HX=").Trim(charsToTrim)) != "")
{
HX = GetCoordinateX(param);
}
if ((param = GetString(line, "|HY=").Trim(charsToTrim)) != "")
{
HY = GetCoordinateY(param);
}
if ((param = GetString(line, "|REFERENCE0POINTX=").Trim(charsToTrim)) != "")
{
REFERENCE0POINTX = GetCoordinateX(param);
}
if ((param = GetString(line, "|REFERENCE0POINTY=").Trim(charsToTrim)) != "")
{
REFERENCE0POINTY = GetCoordinateY(param);
}
if ((param = GetString(line, "|REFERENCE1POINTX=").Trim(charsToTrim)) != "")
{
REFERENCE1POINTX = GetCoordinateX(param);
}
if ((param = GetString(line, "|REFERENCE1POINTY=").Trim(charsToTrim)) != "")
{
REFERENCE1POINTY = GetCoordinateY(param);
}
if ((param = GetString(line, "|TEXTPOSITION=")) != "")
{
TextPosition = param;
}
if ((param = GetString(line, "|ANGLE=").Trim(charsToTrim)) != "")
{
ANGLE = Math.Round(Convert.ToDouble(param), Precision);
if (ANGLE == 180 || ANGLE == 360)
{
ANGLE = 0;
}
if (ANGLE == 270)
{
ANGLE = 90;
}
}
if ((param = GetString(line, "|ARROWSIZE=").Trim(charsToTrim)) != "")
{
ARROWSIZE = GetNumberInMM(param);
}
if ((param = GetString(line, "|ARROWLINEWIDTH=").Trim(charsToTrim)) != "")
{
ARROWLINEWIDTH = GetNumberInMM(param);
}
if ((param = GetString(line, "|ARROWLENGTH=").Trim(charsToTrim)) != "")
{
ARROWLENGTH = GetNumberInMM(param);
}
if ((param = GetString(line, "|LINEWIDTH=").Trim(charsToTrim)) != "")
{
LINEWIDTH = GetNumberInMM(param);
}
if ((param = GetString(line, "|TEXTHEIGHT=").Trim(charsToTrim)) != "")
{
TEXTHEIGHT = GetNumberInMM(param);
}
if ((param = GetString(line, "|TEXTWIDTH=").Trim(charsToTrim)) != "")
{
TEXTWIDTH = GetNumberInMM(param);
}
if ((param = GetString(line, "|TEXTHEIGHT=").Trim(charsToTrim)) != "")
{
TEXTHEIGHT = GetNumberInMM(param);
}
if ((param = GetString(line, "|TEXTX=").Trim(charsToTrim)) != "")
{
TEXTX = GetCoordinateX(param);
}
if ((param = GetString(line, "|TEXTY=").Trim(charsToTrim)) != "")
{
TEXTY = GetCoordinateY(param);
}
if ((param = GetString(line, "|TEXT1X=").Trim(charsToTrim)) != "")
{
TEXT1X = GetCoordinateX(param);
}
if ((param = GetString(line, "|TEXT1Y=").Trim(charsToTrim)) != "")
{
TEXT1Y = GetCoordinateY(param);
}
if ((param = GetString(line, "|TEXTPRECISION=").Trim(charsToTrim)) != "")
{
TEXTPRECISION = Convert.ToInt32(param);
}
if ((param = GetString(line, "|TEXTFORMAT=").Trim(charsToTrim)) != "")
{
TextFormat = Convert.ToInt32(param);
}
if ((param = GetString(line, "|TEXTDIMENSIONUNIT=").Trim(charsToTrim)) != "")
{
DimensionUnit = param;
}
// translate to fit in worksheet
Point2D R0 = new Point2D(REFERENCE0POINTX, REFERENCE0POINTY);
Point2D R1 = new Point2D(REFERENCE1POINTX, REFERENCE1POINTY);
Point2D centre = new Point2D(X1, Y1);
// rotate the two reference points to make horizontal dimension
R0 = R0.Rotate(centre, -ANGLE);
R1 = R1.Rotate(centre, -ANGLE);
Point2D end = new Point2D(R1.X, Y1);
Point2D a1a = new Point2D(X1 + ARROWSIZE, Y1 + ARROWSIZE / 3);
Point2D a1b = new Point2D(X1 + ARROWSIZE, Y1 - ARROWSIZE / 3);
Point2D a2a = new Point2D(end.X - ARROWSIZE, end.Y + ARROWSIZE / 3);
Point2D a2b = new Point2D(end.X - ARROWSIZE, end.Y - ARROWSIZE / 3);
CheckMinMax(X1, Y1);
CheckMinMax(end.X, end.Y);
CheckMinMax(a1a.X, a1a.Y);
CheckMinMax(a1b.X, a1b.Y);
CheckMinMax(a2a.X, a2a.Y);
CheckMinMax(a2b.X, a2b.Y);
}
private bool CanMove(Position pos)
{
Piece p = Brd.Piece(pos);
return(p == null || p.Color != Color);
}
private bool IsThereEnemy(Position pos)
{
Piece p = Brd.Piece(pos);
return(p != null && p.Color != Color);
}
public void PutNewPiece(char column, int row, Piece piece)
{
Brd.PutPiece(piece, new ChessPosition(column, row).ToPosition());
Pieces.Add(piece);
}
public override bool ProcessLine(byte[] line)
{
double X1, Y1, X2, Y2, width;
int net;
Layers layer;
bool InComponent = false;
Int16 component = 0;
base.ProcessLine();
net = B2UInt16(line, 3 + 5);
if (net == 0x0000FFFF)
{
net = 0;
}
else
{
net++;
}
component = B2Int16(line, 7 + 5);
InComponent = (component != -1);
X1 = Math.Round(ToMM(line, 13 + 5) - originX, Precision);
Y1 = Math.Round(ToMM(line, 17 + 5) - originY, Precision);
X2 = Math.Round(ToMM(line, 21 + 5) - originX, Precision);
Y2 = Math.Round(ToMM(line, 25 + 5) - originY, Precision);
CheckMinMax(X1 + originX, Y1 + originY);
CheckMinMax(X2 + originX, Y2 + originY);
width = Math.Round(ToMM(line, 29 + 5), Precision);
layer = (Layers)line[5];
string Layer = Brd.GetLayer(layer);
int ComponentNumber = 0;
if (InComponent)
{
// belongs to a component definition
ComponentNumber = component;
}
// check for and reject very short tracks
if (Length(X1, Y1, X2, Y2) <= 0.001)
{
OutputError($"Zero length track rejected at X1={X1} Y1={-Y1} X2={X2} y2={-Y2} ");
return(true);
}
if (!InComponent)
{
if (net == 0)
{
if (!Brd.OnInnerLayer(layer))
{
if ((Layer != "Edge.Cuts") || !Brd.CheckExistingLine(X1, -Y1, X2, -Y2))
{
List <string> Layers = Brd.GetLayers(Layer);
foreach (var L in Layers)
{
Line Line = new Line(X1, Y1, X2, Y2, L, width, net);
LinesL.Add(Line);
}
}
}
}
else
{
Line Line = new Line(X1, Y1, X2, Y2, Brd.GetLayer(layer), width, net);
LinesL.Add(Line);
//tracks.Append($" (segment (start {X1} {-Y1}) (end {X2} {-Y2}) (width {width}) (layer {Layer}) (net {net}))\n");
//track_count++;
}
}
else
{
Line Line = new Line(X1, Y1, X2, Y2, Brd.GetLayer(layer), width);
ModulesL[ComponentNumber].Lines.Add(Line);
}
return(true);
}
public override bool[,] PossibleMovements()
{
bool[,] mat = new bool[Brd.Rows, Brd.Columns];
Position pos = new Position(0, 0);
//North
pos.SetValues(Position.Row - 1, Position.Column);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
//North-East
pos.SetValues(Position.Row - 1, Position.Column + 1);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
//East
pos.SetValues(Position.Row, Position.Column + 1);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
//South-East
pos.SetValues(Position.Row + 1, Position.Column + 1);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
//South
pos.SetValues(Position.Row + 1, Position.Column);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
//South-West
pos.SetValues(Position.Row + 1, Position.Column - 1);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
//West
pos.SetValues(Position.Row, Position.Column - 1);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
//North-West
pos.SetValues(Position.Row - 1, Position.Column - 1);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
//#Special Play: Castling
if (MovementsQty == 0 && !Match.Check)
{
//Castling Short
Position posR1 = new Position(Position.Row, Position.Column + 3);
if (CastlingTest(posR1))
{
Position p1 = new Position(Position.Row, Position.Column + 1);
Position p2 = new Position(Position.Row, Position.Column + 2);
if (Brd.Piece(p1) == null && Brd.Piece(p2) == null)
{
mat[Position.Row, Position.Column + 2] = true;
}
}
//Castling Long
Position posR2 = new Position(Position.Row, Position.Column - 4);
if (CastlingTest(posR2))
{
Position p1 = new Position(Position.Row, Position.Column - 1);
Position p2 = new Position(Position.Row, Position.Column - 2);
Position p3 = new Position(Position.Row, Position.Column - 3);
if (Brd.Piece(p1) == null && Brd.Piece(p2) == null && Brd.Piece(p3) == null)
{
mat[Position.Row, Position.Column - 2] = true;
}
}
}
return(mat);
}
private bool CastlingTest(Position pos)
{
Piece p = Brd.Piece(pos);
return(p != null && p is Rook && p.Color == Color && p.MovementsQty == 0);
}
public override bool[,] PossibleMovements()
{
bool[,] mat = new bool[Brd.Rows, Brd.Columns];
Position pos = new Position(0, 0);
if (Color == Color.White)
{
pos.SetValues(Position.Row - 1, Position.Column);
if (Brd.IsValidPosition(pos) && Free(pos))
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row - 2, Position.Column);
Position p2 = new Position(Position.Row - 1, Position.Column);
if (Brd.IsValidPosition(p2) && Free(p2) && Brd.IsValidPosition(pos) && Free(pos) && MovementsQty == 0)
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row - 1, Position.Column - 1);
if (Brd.IsValidPosition(pos) && IsThereEnemy(pos))
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row - 1, Position.Column + 1);
if (Brd.IsValidPosition(pos) && IsThereEnemy(pos))
{
mat[pos.Row, pos.Column] = true;
}
//#Special Play: En Passant
if (Position.Row == 3)
{
Position left = new Position(Position.Row, Position.Column - 1);
if (Brd.IsValidPosition(left) && IsThereEnemy(left) && Brd.Piece(left) == Match.VulnerableEnPassant)
{
mat[left.Row - 1, left.Column] = true;
}
Position right = new Position(Position.Row, Position.Column + 1);
if (Brd.IsValidPosition(right) && IsThereEnemy(right) && Brd.Piece(right) == Match.VulnerableEnPassant)
{
mat[right.Row - 1, right.Column] = true;
}
}
}
else
{
pos.SetValues(Position.Row + 1, Position.Column);
if (Brd.IsValidPosition(pos) && Free(pos))
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row + 2, Position.Column);
Position p2 = new Position(Position.Row + 1, Position.Column);
if (Brd.IsValidPosition(p2) && Free(p2) && Brd.IsValidPosition(pos) && Free(pos) && MovementsQty == 0)
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row + 1, Position.Column - 1);
if (Brd.IsValidPosition(pos) && IsThereEnemy(pos))
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row + 1, Position.Column + 1);
if (Brd.IsValidPosition(pos) && IsThereEnemy(pos))
{
mat[pos.Row, pos.Column] = true;
}
//#Special Play: En Passant
if (Position.Row == 4)
{
Position left = new Position(Position.Row, Position.Column - 1);
if (Brd.IsValidPosition(left) && IsThereEnemy(left) && Brd.Piece(left) == Match.VulnerableEnPassant)
{
mat[left.Row + 1, left.Column] = true;
}
Position right = new Position(Position.Row, Position.Column + 1);
if (Brd.IsValidPosition(right) && IsThereEnemy(right) && Brd.Piece(right) == Match.VulnerableEnPassant)
{
mat[right.Row + 1, right.Column] = true;
}
}
}
return(mat);
}
public override bool ProcessLine(byte[] record)
{
Layers Layer;
Int16 Component;
bool InComponent;
base.ProcessLine();
using (MemoryStream ms = new MemoryStream(record))
{
// Use the memory stream in a binary reader.
using (BinaryReader br = new BinaryReader(ms))
{
try
{
ms.Seek(0, SeekOrigin.Begin);
Layer = (Layers)br.ReadByte();
ms.Seek(1, SeekOrigin.Begin);
short Flags = (short)br.ReadInt16();
ms.Seek(3, SeekOrigin.Begin);
int net = (int)br.ReadInt16() + 1;
ms.Seek(7, SeekOrigin.Begin);
Component = br.ReadInt16();
InComponent = Component != -1;
ms.Seek(0x12, SeekOrigin.Begin);
int strlen = br.ReadInt32();
ms.Seek(0x16, SeekOrigin.Begin);
byte[] bytes = br.ReadBytes(strlen);
string str = ConvertToString(bytes);
ms.Seek(0x16 + strlen, SeekOrigin.Begin);
Int32 DataLen = br.ReadInt32();
string l = Brd.GetLayer((Layers)Layer);
Region r = new Region(l, net, Flags, str);
if (r.SubPolyIndex > 0)
{
// Rejected region
return(true);
}
while (DataLen-- > 0)
{
double X = Math.Round(ToMM(br.ReadDouble()) - originX, Precision);
double Y = Math.Round(ToMM(br.ReadDouble()) - originY, Precision);
r.AddPoint(X, Y);
}
if (!InComponent)
{
RegionsL.Add(r);
}
else
{
if (!r.Keepout && !r.PolygonCutout)
{
ModulesL[Component].Regions.Add(r);
}
else
{
// until keepouts are allowed in components
// just add as a board region
RegionsL.Add(r);
}
}
}
catch (Exception Ex)
{
CheckThreadAbort(Ex);
}
}
}
return(true);
}
public Dimension(string line)
{
string param;
if ((param = GetString(line, "|X1=").Trim(charsToTrim)) != "")
{
X1 = GetCoordinateX(param);
}
if ((param = GetString(line, "|Y1=").Trim(charsToTrim)) != "")
{
Y1 = GetCoordinateY(param);
}
if ((param = GetString(line, "|X2=").Trim(charsToTrim)) != "")
{
X2 = GetCoordinateX(param);
}
if ((param = GetString(line, "|Y2=").Trim(charsToTrim)) != "")
{
Y2 = GetCoordinateY(param);
}
if ((param = GetString(line, "|DIMENSIONKIND=")) != "")
{
DIMENSIONKIND = Convert.ToInt16(param);
}
if ((param = GetString(line, "|DIMENSIONLAYER=")) != "")
{
layer = Brd.GetLayer(param);
}
if ((param = GetString(line, "|LX=").Trim(charsToTrim)) != "")
{
LX = GetCoordinateX(param);
}
if ((param = GetString(line, "|LY=").Trim(charsToTrim)) != "")
{
LY = GetCoordinateY(param);
}
if ((param = GetString(line, "|HX=").Trim(charsToTrim)) != "")
{
HX = GetCoordinateX(param);
}
if ((param = GetString(line, "|HY=").Trim(charsToTrim)) != "")
{
HY = GetCoordinateY(param);
}
if ((param = GetString(line, "|REFERENCE0POINTX=").Trim(charsToTrim)) != "")
{
REFERENCE0POINTX = GetCoordinateX(param);
}
if ((param = GetString(line, "|REFERENCE0POINTY=").Trim(charsToTrim)) != "")
{
REFERENCE0POINTY = GetCoordinateY(param);
}
if ((param = GetString(line, "|REFERENCE1POINTX=").Trim(charsToTrim)) != "")
{
REFERENCE1POINTX = GetCoordinateX(param);
}
if ((param = GetString(line, "|REFERENCE1POINTY=").Trim(charsToTrim)) != "")
{
REFERENCE1POINTY = GetCoordinateY(param);
}
if ((param = GetString(line, "|ANGLE=").Trim(charsToTrim)) != "")
{
ANGLE = Math.Round(Convert.ToDouble(param), Precision);
if (ANGLE == 180 || ANGLE == 360)
{
ANGLE = 0;
}
if (ANGLE == 270)
{
ANGLE = 90;
}
}
if ((param = GetString(line, "|ARROWSIZE=").Trim(charsToTrim)) != "")
{
ARROWSIZE = GetNumberInMM(param);
}
if ((param = GetString(line, "|ARROWLINEWIDTH=").Trim(charsToTrim)) != "")
{
ARROWLINEWIDTH = GetNumberInMM(param);
}
if ((param = GetString(line, "|ARROWLENGTH=").Trim(charsToTrim)) != "")
{
ARROWLENGTH = GetNumberInMM(param);
}
if ((param = GetString(line, "|LINEWIDTH=").Trim(charsToTrim)) != "")
{
LINEWIDTH = GetNumberInMM(param);
}
if ((param = GetString(line, "|TEXTHEIGHT=").Trim(charsToTrim)) != "")
{
TEXTHEIGHT = GetNumberInMM(param);
}
if ((param = GetString(line, "|TEXTWIDTH=").Trim(charsToTrim)) != "")
{
TEXTWIDTH = GetNumberInMM(param);
}
if ((param = GetString(line, "|TEXTHEIGHT=").Trim(charsToTrim)) != "")
{
TEXTHEIGHT = GetNumberInMM(param);
}
if ((param = GetString(line, "|TEXTX=").Trim(charsToTrim)) != "")
{
TEXTX = GetCoordinateX(param);
}
if ((param = GetString(line, "|TEXTY=").Trim(charsToTrim)) != "")
{
TEXTY = GetCoordinateY(param);
}
if ((param = GetString(line, "|TEXT1X=").Trim(charsToTrim)) != "")
{
TEXT1X = GetCoordinateX(param);
}
if ((param = GetString(line, "|TEXT1Y=").Trim(charsToTrim)) != "")
{
TEXT1Y = GetCoordinateY(param);
}
if ((param = GetString(line, "|TEXTPRECISION=").Trim(charsToTrim)) != "")
{
TEXTPRECISION = Convert.ToInt32(param);
}
if ((param = GetString(line, "|TEXTDIMENSIONUNIT=").Trim(charsToTrim)) != "")
{
DimensionUnit = param;
}
}
private bool Free(Position pos)
{
return(Brd.Piece(pos) == null);
}
public override string ToString()
{
StringBuilder ret = new StringBuilder("");
string connectstyle = "";
if (SubPolyIndex != -1)
{
OutputError("Reject region");
return("");
}
double clearance = GetRuleValue(this, "Clearance", "PolygonClearance");
if (Layer.Substring(0, 2) == "In")
{
// this is an inner layer so use plane clearance
clearance = GetRuleValue(this, "PlaneClearance", "PlaneClearance");
}
if (Layer != "Edge.Cuts")
{
List <string> Layers = Brd.GetLayers(Layer);
foreach (var L in Layers)
{
ret.Append($" (zone (net {Net_no}) (net_name {Net_name}) (layer {L}) (hatch edge 0.508)");
ret.Append($" (priority 100)\n");
ret.Append($" (connect_pads {connectstyle} (clearance {clearance}))\n"); // TODO sort out these numbers properly
ret.Append($" (min_thickness 0.2)\n");
if (Keepout)
{
ret.Append("(keepout(copperpour not_allowed))\n");
}
else if (PolygonCutout)
{
ret.Append("(keepout (tracks not_allowed) (vias allowed) (copperpour not_allowed))");
}
string fill = (Layer == "Edge.Cuts") ? "no" : "yes";
ret.Append($" (fill {fill} (arc_segments 16) (thermal_gap 0.2) (thermal_bridge_width 0.3))\n");
var i = 0;
ret.Append(" (polygon (pts\n ");
foreach (var Point in Points)
{
i++;
if ((i % 5) == 0)
{
ret.Append("\n ");
}
ret.Append(Point.ToString());
}
ret.Append("\n )\n )\n )\n");
}
}
else
{
Point Start = new Point(0, 0);
Start = Points[0];
int i;
for (i = 0; i < Points.Count - 1; i++)
{
ret.Append($" (gr_line (start {Points[i].X} {-Points[i].Y}) (end {Points[i + 1].X} {-Points[i + 1].Y}) (layer Edge.Cuts) (width 0.1))\n");
}
ret.Append($" (gr_line (start {Points[i].X} {-Points[i].Y}) (end {Start.X} {-Start.Y}) (layer Edge.Cuts) (width 0.1))\n");
}
return(ret.ToString());
}
public override bool ProcessLine(byte[] record)
{
base.ProcessLine();
using (MemoryStream ms = new MemoryStream(record))
{
// Use the memory stream in a binary reader.
using (BinaryReader br = new BinaryReader(ms))
{
ms.Seek(0, SeekOrigin.Begin);
Layer = (Layers)br.ReadByte(); // line offset 0
Locked = br.ReadByte(); // line offset 1
Keepout = (int)br.ReadByte(); // line offset 2
ms.Seek(3, SeekOrigin.Begin);
Net = br.ReadInt16();
Net += 1;
NetName = $"\"{NetsL[Net].Name}\"";
ms.Seek(7, SeekOrigin.Begin);
Component = br.ReadInt16();
InComponent = (Component != -1);
ms.Seek(13, SeekOrigin.Begin);
X1 = Math.Round(Bytes2mm(br.ReadBytes(4)) - originX, Precision);
ms.Seek(17, SeekOrigin.Begin);
Y1 = Math.Round(Bytes2mm(br.ReadBytes(4)) - originY, Precision);
ms.Seek(21, SeekOrigin.Begin);
X2 = Math.Round(Bytes2mm(br.ReadBytes(4)) - originX, Precision);
ms.Seek(25, SeekOrigin.Begin);
Y2 = Math.Round(Bytes2mm(br.ReadBytes(4)) - originY, Precision);
ms.Seek(29, SeekOrigin.Begin);
Rotation = br.ReadDouble();
CheckMinMax(X1, Y1);
CheckMinMax(X2, Y2);
}
if (Keepout == 2)
{
Point2D p1 = new Point2D(X1, Y1);
Point2D p2 = new Point2D(X2, Y2);
Point2D c = new Point2D(X1 + (X2 - X1) / 2, Y1 + (Y2 - Y1) / 2);
if (InComponent)
{
// need to factor in component's rotation
if (Component < ModulesL.Count)
{
try
{
double rot = ModulesL[Component].Rotation;
p1 = p1.Rotate(c, rot);
p2 = p2.Rotate(c, rot);
}
catch (Exception Ex)
{
CheckThreadAbort(Ex);
}
}
}
string layer = "";
if (Layer == Layers.Keepout_Layer)
{
layer = "*.Cu";
}
else
{
layer = Brd.GetLayer(Layer);
}
List <string> layers = Brd.GetLayers(layer);
foreach (var L in layers)
{
// generate a keepout
keepouts.Append(
$@"
(zone(net 0)(net_name """")(layers {L})(tstamp 0)(hatch edge 0.508)
(connect_pads(clearance 0.508))
(min_thickness 0.254)
(keepout(tracks not_allowed)(vias not_allowed)(copperpour not_allowed))
(fill(arc_segments 32)(thermal_gap 0.508)(thermal_bridge_width 0.508))
(polygon
(pts
(xy {p1.X} {-p1.Y})(xy {p2.X} {-p1.Y})(xy {p2.X} {-p2.Y})(xy {p1.X} {-p2.Y})
)
)
)
");
}
}
else if (!InComponent) // keepouts not allowed in components (yet)
{
List <string> Layers = Brd.GetLayers(Brd.GetLayer(Layer));
foreach (var L in Layers)
{
fills.Append($" (gr_poly (pts (xy {X1} {-(Y1)}) (xy {X1} {-(Y2)}) (xy {X2} {-(Y2)}) (xy {X2} {-(Y1)})) (layer {L}) (width 0))\n");
}
}
else
{
Fill Fill = new Fill(X1, Y1, X2, Y2, Brd.GetLayer(Layer), GetNetName(Net));
if (Component < ModulesL.Count && Component != -1)
{
ModulesL[Component].Fills.Add(Fill);
}
}
return(true);
}
}
public override bool ProcessBinaryFile(byte[] data)
{
StartTimer();
if (Binary_size == 0)
{
return(false);
}
long p = 0;
Int32 len;
string str = "";
try
{
using (MemoryStream ms = new MemoryStream(data))
{
long size = ms.Length;
if (size == 0)
{
return(true);
}
BinaryReader br = new BinaryReader(ms, System.Text.Encoding.UTF8);
while (p < size)
{
base.ProcessLine(); // keep count
byte record_type = br.ReadByte();
if (record_type != 5)
{
break;
}
len = br.ReadInt32();
byte[] bytes = br.ReadBytes(len); // 0xEC); // read the number of bytes up to actual text
// map text structure to the bytes
Text text = ByteArrayToStructure <Text>(bytes);
Layers Layer = (Layers)text.Layer;
Int16 Component = text.Component;
bool InComponent = Component != -1;
double X = Math.Round(ToMM(text.X) - originX, Precision);
double Y = Math.Round(ToMM(text.Y) - originY, Precision);
double Height = Math.Round(ToMM(text.Height), Precision);
double Width = Math.Round(ToMM(text.Height), Precision);
double Rotation = text.Rotation % 360; // altium seem to store 0 as 360 quite a lot!
bool Mirror = text.Mirror != 0;
double Thickness = ToMM(text.Thickness);
bool IsComment = text.IsComment != 0;
bool IsDesignator = text.IsDesignator != 0;
bool TrueType = text.TrueType != 0;
UInt32 TextLen = br.ReadUInt32();
bool Italic = text.Italic != 0;
bool Bold = text.Bold != 0;
byte strlen = br.ReadByte();
byte[] textbytes = br.ReadBytes(strlen);
p = ms.Position; // now at end of record
str = Encoding.UTF8.GetString(textbytes, 0, strlen);
string layer = Brd.GetLayer(Layer);
str = ConvertSpecialStrings(str, Component, layer);
if (TrueType)
{
//string Font = text.FontName;
StringBuilder SB = new StringBuilder("");
unsafe
{
for (int i = 0; i < 32; i++)
{
if (text.FontName[i] == 0)
{
break;
}
char c = (char)text.FontName[i];
SB.Append(c);
}
}
string Font = SB.ToString();
TTFont F;
FontFamily fontFamily = null;
try
{
fontFamily = new FontFamily(Font);
// check if font is on font list
if ((F = FindFont(Font, Bold, Italic, Height)) == null)
{
// get metrics for font and bung it onto font list
FontStyle Style = ((Bold) ? FontStyle.Bold : 0) | ((Italic) ? FontStyle.Italic : 0);
Font font = new Font(fontFamily, 100, Style, GraphicsUnit.Pixel);
float Ascent = font.FontFamily.GetCellAscent(Style);
float Descent = font.FontFamily.GetCellDescent(Style);
float EmHeight = font.FontFamily.GetEmHeight(Style);
float TotalHeight = Ascent + Descent;
float InternalLeading = TotalHeight - EmHeight;
double TTHeight = (float)(Ascent - InternalLeading);
F = new TTFont
{
FontName = Font,
Italic = Italic,
Bold = Bold,
TotalHeight = TotalHeight,
TTHeight = TTHeight,
Height = Height
};
Height = Height / F.TotalHeight * F.TTHeight;
Height = Height - Height / 5;
F.TTHeight = Height;
Size CharWidth = TextRenderer.MeasureText("A", font);
F.CharWidth = Height * ((float)CharWidth.Height / (float)CharWidth.Width);
Fonts.Add(F);
}
Height = F.TTHeight;
Thickness = Height / (Bold ? 5 : 10);
Width = F.CharWidth;
}
catch (ArgumentException)
{
OutputError($"Font {Font} does not exist on this computer");
// couldn't find font so estimate size
Height = Height / 2;
Width = Height;
}
}
str = str.Replace("\r", "");
str = str.Replace("\n", "\\n");
if (!InComponent)
{
double Angle = (90 - Rotation) * Math.PI / 180;
double X1 = Height / 2 * Math.Cos(Angle);
double Y1 = Height / 2 * Math.Sin(Angle);
List <string> Layers = Brd.GetLayers(layer);
foreach (var L in Layers)
{
string It = Italic ? "italic" : "";
texts.Append($" (gr_text \"{ToLiteral(str)}\" (at {Math.Round(X - X1, Precision)} {-Math.Round(Y + Y1, Precision)} {Math.Round(Rotation, Precision)}) (layer {L}) (effects (font (size {Height} {Width}) (thickness {Thickness}) {It}) (justify left {(Mirror ? "mirror" : "")})))\n");
}
}
else
{
Module Mod = ModulesL[Component];
string Hide = "";
string type = "";
if (IsDesignator)
{
type = "reference";
Hide = Mod.DesignatorOn ? "" : "hide";
if (Brd.DesignatorDisplayMode && str.Contains("_"))
{
// This is a virtual designator
// Pcbnew doesn't have anything like this so
// set the designator onto the Dwgs.User layer
// and put a copy minus the channel designator on the
// top/bottom overlay layer
// str = str.Substring(0, str.IndexOf('_'));
}
Mod.Designator = str;
}
else if (IsComment)
{
type = "value";
Hide = Mod.CommentOn ? "" : "hide";
if (layer == "F.Cu")
{
layer = "F.Fab";
}
else
if (layer == "B.Cu")
{
layer = "B.Fab";
}
/*if (Brd.DesignatorDisplayMode)
* {
* // should get the seperator from the project file (.PrjPCB)
* // under ChannelRoomLevelSeperator
* // can't find it in board data assume it's '_'
* str = str.Substring(0, str.IndexOf('_'));
* }*/
Mod.Comment = ToLiteral(str);
}
else
{
type = "user";
if (str == Mod.Comment)
{
str = "%V";
}
if (str == Mod.Designator)
{
str = "%R";
}
}
if (Hide == "")
{
GetBoundingBox(str, X, Y, Rotation, Height, Width);
}
if (Brd.DesignatorDisplayMode && str.Contains("_"))
{
// put designator on Dwgs.User and virtual designator on silkscreen
String S1 = new String(type, str, X, Y, Rotation, "Dwgs.User", Height, Width, Thickness, Hide, Mirror, Italic);
ModulesL[Component].Strings.Add(S1);
str = str.Substring(0, str.IndexOf('_'));
String S2 = new String("user", str, X, Y, Rotation, layer, Height, Width, Thickness, Hide, Mirror, Italic);
ModulesL[Component].Strings.Add(S2);
}
else
{
String String = new String(type, str, X, Y, Rotation, layer, Height, Width, Thickness, Hide, Mirror, Italic);
ModulesL[Component].Strings.Add(String);
}
}
}
}
}
catch (Exception Ex)
{
CheckThreadAbort(Ex);
}
return(true);
}
public Polygon(string line) // string Layer, int net)
{
string param;
ObjectType = PCBObjectType.Polygon;
Int32 net = 0;
if ((param = GetString(line, "|NET=")) != "")
{
net = Convert.ToInt32(param) + 1;
}
string Net = GetNetName(net);
if ((param = GetString(line, "|COMPONENT=")) != "")
{
Component = Convert.ToInt32(param);
InComponent = true;
}
if ((param = GetString(line, "|LAYER=")) != "")
{
Layer = Brd.GetLayer(param);
}
IsSplitPlane = ((param = GetString(line, "|POLYGONTYPE=")) == "Split Plane");
if (!IsSplitPlane && (param = GetString(line, "|TRACKWIDTH=")) != "")
{
TrackWidth = Convert.ToDouble(GetNumberInMM(param));
}
else
{
TrackWidth = 0.1; // maybe should be smaller for split plane
NeckWidthThreshold = 0.1;
}
if ((param = GetString(line, "|POURINDEX=")) != "")
{
PourIndex = Convert.ToInt16(param);
if (PourIndex > Brd.MaxPourIndex)
{
Brd.MaxPourIndex = PourIndex;
}
}
if ((param = GetString(line, "|NECKWIDTHTHRESHOLD=")) != "")
{
NeckWidthThreshold = GetNumberInMM(param.Trim(charsToTrim));
}
NetNo = net;
NetName = GetNetName(NetNo);
Points = new List <Point>();
string[] coords = line.Split('|');
// now add all the vertices
for (var j = 0; j < coords.Length; j++)
{
if (coords[j].StartsWith("KIND"))
{
var start = coords[j].IndexOf('=') + 1;
string type = coords[j].Substring(start);
j++;
start = coords[j].IndexOf('=') + 1;
string coord = coords[j].Substring(start);
// get start X
double VX = GetCoordinateX(coord.Trim(charsToTrim));
j++;
start = coords[j].IndexOf('=') + 1;
coord = coords[j].Substring(start);
// get start Y
double VY = GetCoordinateY(coord.Trim(charsToTrim));
j++;
start = coords[j].IndexOf('=') + 1;
coord = coords[j].Substring(start);
// get centre X
double CX = GetCoordinateX(coord.Trim(charsToTrim));
j++;
start = coords[j].IndexOf('=') + 1;
coord = coords[j].Substring(start);
// get centre Y
double CY = GetCoordinateY(coord.Trim(charsToTrim));
j++;
start = coords[j].IndexOf('=') + 1;
coord = coords[j].Substring(start);
// get start angle
double SA = GetDouble(coord.Trim(charsToTrim));
j++;
start = coords[j].IndexOf('=') + 1;
coord = coords[j].Substring(start);
// get end angle
double EA = GetDouble(coord.Trim(charsToTrim));
j++;
start = coords[j].IndexOf('=') + 1;
coord = coords[j].Substring(start);
// get radius
double R = GetNumberInMM(coord.Trim(charsToTrim));
if (type == "0")
{
// straight line
AddPoint(Math.Round(VX, Precision), Math.Round(VY, Precision));
}
else
{
// this is an arc so have to simulate arc with a number of line segments
// first normalise it so that the centre is at 0,0
// save the centre point
double XC = CX;
double YC = CY;
double X = VX - XC;
double Y = VY - YC;
// generate arc segments at 5° increments
if (EA < SA)
{
EA += 360;
}
// start point of arc
X = R * Math.Cos(Arc.Radians(SA));
Y = R * Math.Sin(Arc.Radians(SA));
// end point of arc
double X2 = R * Math.Cos(Arc.Radians(EA));
double Y2 = R * Math.Sin(Arc.Radians(EA));
bool clockwise = true;
double l1 = Math.Sqrt((VX - (X + XC)) * (VX - (X + XC)) + (VY - (Y + YC)) * (VY - (Y + YC)));
double l2 = Math.Sqrt((VX - (X2 + XC)) * (VX - (X2 + XC)) + (VY - (Y2 + YC)) * (VY - (Y2 + YC)));
if (l1 < l2)
{
clockwise = false;
}
// need to determine if this is clockwise or anticlockwise as the
// start and end angles are back to front
if (!clockwise)
{
// anticlockwise
for (double angle = SA; angle < EA; angle += 5)
{
double X1 = R * Math.Cos(Arc.Radians(angle));
double Y1 = R * Math.Sin(Arc.Radians(angle));
AddPoint(X + XC, Y + YC);
X = X1;
Y = Y1;
}
// do last segment
if (X != X2 || Y != Y2)
{
AddPoint(X2 + XC, Y2 + YC);
}
}
else
{
// clockwise
// start point of arc
X = R * Math.Cos(Arc.Radians(EA));
Y = R * Math.Sin(Arc.Radians(EA));
// end point of arc
X2 = R * Math.Cos(Arc.Radians(SA));
Y2 = R * Math.Sin(Arc.Radians(SA));
for (double angle = EA; angle > SA; angle -= 5)
{
double X1 = R * Math.Cos(Arc.Radians(angle));
double Y1 = R * Math.Sin(Arc.Radians(angle));
AddPoint(X + XC, Y + YC);
X = X1;
Y = Y1;
}
// do last segment
if (X != X2 || Y != Y2)
{
AddPoint(X2 + XC, Y2 + YC);
}
}
}
}
}
}
public override string ToString()
{
if (DIMENSIONKIND != 1) // TODO fix this - filter out radial dimensions
{
OutputError($"Unsupported Dimension kind ({DIMENSIONKIND}) at {X1},{Y1}");
return("");
}
// translate to fit in worksheet
Point2D R0 = new Point2D(REFERENCE0POINTX, REFERENCE0POINTY);
Point2D R1 = new Point2D(REFERENCE1POINTX, REFERENCE1POINTY);
Point2D centre = new Point2D(X1, Y1);
// rotate the two reference points to make horizontal dimension
R0 = R0.Rotate(centre, -ANGLE);
R1 = R1.Rotate(centre, -ANGLE);
Point2D end = new Point2D(R1.X, Y1);
// calculate the length of the crossbar
length = R1.X - X1; // length in mm
// calculate the end points of the arrow features
Point2D a1a = new Point2D(X1 + ARROWSIZE, Y1 + ARROWSIZE / 3);
Point2D a1b = new Point2D(X1 + ARROWSIZE, Y1 - ARROWSIZE / 3);
Point2D a2a = new Point2D(end.X - ARROWSIZE, end.Y + ARROWSIZE / 3);
Point2D a2b = new Point2D(end.X - ARROWSIZE, end.Y - ARROWSIZE / 3);
if (length < 0)
{
// there must be a better way to do this but hey ho
length = -length;
// calculate the end points of the arrow features
a1a = new Point2D(X1 - ARROWSIZE, Y1 + ARROWSIZE / 3);
a1b = new Point2D(X1 - ARROWSIZE, Y1 - ARROWSIZE / 3);
a2a = new Point2D(end.X + ARROWSIZE, end.Y + ARROWSIZE / 3);
a2b = new Point2D(end.X + ARROWSIZE, end.Y - ARROWSIZE / 3);
}
string units;
int UnitsIndex = 0;
int Ilength;
int Dlength;
// convert length to string based on Units and precision
switch (DimensionUnit)
{
case "Mils":
length = length / 25.4 * 1000;
units = "mil";
UnitsIndex = 1;
break;
case "Millimeters":
units = "mm";
UnitsIndex = 2;
break;
case "Inches":
length = length / 25.4;
units = "in";
UnitsIndex = 0;
break;
case "Centimeters":
length = length / 10;
units = "cm";
UnitsIndex = 2; // no CM in Pcbnew (yet)
break;
default: // mm
units = "mm";
UnitsIndex = 2;
break;
}
length = Math.Round(length, TEXTPRECISION);
Int32 MP = Convert.ToInt32(Math.Pow(10, TEXTPRECISION));
Int32 FP = Convert.ToInt32(length * Math.Pow(10, TEXTPRECISION));
Ilength = FP / MP;
Dlength = FP - Ilength * MP;
string Decimal = Dlength.ToString("D" + TEXTPRECISION);
if (TEXTPRECISION == 0)
{
text = $"{Ilength}{units}";
}
else
{
text = $"{Ilength}.{Decimal}{units}";
}
// rotate all the points back
a1a = a1a.Rotate(centre, ANGLE);
a1b = a1b.Rotate(centre, ANGLE);
a2a = a2a.Rotate(centre, ANGLE);
a2b = a2b.Rotate(centre, ANGLE);
R0 = R0.Rotate(centre, ANGLE);
R1 = R1.Rotate(centre, ANGLE);
end = end.Rotate(centre, ANGLE);
var string1 = new StringBuilder("");
var Layers = Brd.GetLayers(Brd.GetLayer(layer));
string Justify = "";
switch (TextPosition)
{
case "Auto": break; // just do centre
case "Center": break; // just do centre
case "Top": break; // just do centre
case "Bottom": break; // just do centre
case "Right": Justify = "(justify right)"; break;
case "Left": Justify = "(justify left)"; break;
case "InsideRight": Justify = "(justify right)"; break;
case "InsideLeft": Justify = "(justify left)"; break;
case "UniDirectional": break; // just do centre
case "Manual": break; // just do centre
}
foreach (var L in Layers)
{
string1.Append($@"
(dimension 176 (width {LINEWIDTH}) (layer {L})
(gr_text {text} (at {TEXT1X} {-TEXT1Y} {ANGLE}) (layer {L.ToString()})
(effects (font (size {Math.Round(TEXTHEIGHT, Precision)} {Math.Round(TEXTHEIGHT, Precision)}) (thickness {Math.Round(LINEWIDTH, Precision)})) {Justify})
)
(format (units {UnitsIndex}) (units_format {1}) (precision {TEXTPRECISION}))
(style (thickness {TEXTWIDTH}) (arrow_length {ARROWLENGTH}) (text_position_mode {1}) (extension_height {1}) (extension_offset 0) keep_text_aligned )
(feature1 (pts (xy {end.X} {-end.Y}) (xy {R1.X} {-R1.Y}) ))
(feature2 (pts (xy {X1} {-Y1}) (xy {R0.X} {-R0.Y})))
(crossbar (pts (xy {X1} {-Y1}) (xy {end.X} {-end.Y})))
(arrow1a (pts (xy {X1} {-Y1}) (xy {a1a.X} {-a1a.Y})))
(arrow1b (pts (xy {X1} {-Y1}) (xy {a1b.X} {-a1b.Y})))
(arrow2a (pts (xy {end.X} {-end.Y}) (xy {a2a.X} {-a2a.Y})))
(arrow2b (pts (xy {end.X} {-end.Y}) (xy {a2b.X} {-a2b.Y})))
)");
}
return(string1.ToString());
}
