public virtual void ApplyKeepUp()
{
if (!_keepUp)
{
return;
}
Quaternion target;
if (_upReferenceObject == null)
{
target = ExtRotation.TurretLookRotation(_toMove.rotation, _upReference);
}
else
{
if (_keepUpGalaxyOriented)
{
target = ExtRotation.TurretLookRotation(_toMove.rotation, _toMove.position - _upReferenceObject.position);
}
else
{
target = ExtRotation.TurretLookRotation(_toMove.rotation, _upReferenceObject.up);
}
}
_toMove.rotation = ExtRotation.OwnSmoothDamp(_toMove.rotation, target, ref _refRotationUpVelocity, _dampingTimeRotation);
}
public ExtPlane3d(Vector3 position, Vector3 normal) : this()
{
_position = position;
_rotation = ExtRotation.QuaternionFromVectorDirector(normal, Vector3.up);
_rotation = ExtRotation.RotateQuaternion(_rotation, new Vector3(-90, 0, 0));
UpdateMatrix();
}
private void SetPcbTextAttributes(k.ModuleDef.fp_text field,
PointF element_pos, ExtRotation element_rot,
PointF attrib_pos, ExtRotation attrib_rot)
{
float angle;
if (element_rot.Mirror)
{
field.position.At = new PointF(attrib_pos.X - element_pos.X, (attrib_pos.Y - element_pos.Y));
angle = MathUtil.NormalizeAngle(attrib_rot.Rotation - element_rot.Rotation);
field.position.At = field.position.At.Rotate(-element_rot.Rotation);
field.position.At.X = -field.position.At.X;
}
else
{
field.position.At = new PointF(attrib_pos.X - element_pos.X, (attrib_pos.Y - element_pos.Y));
angle = MathUtil.NormalizeAngle(attrib_rot.Rotation - element_rot.Rotation);
field.position.At = field.position.At.Rotate(element_rot.Rotation);
//SizeF textSize = strokeFont.GetTextSize(field.Value, field.effects);
// get bottom left
//PointF pivot = field.position.At + new SizeF (-textSize.Width / 2, textSize.Height / 2);
//field.position.At = field.position.At.RotateAt (pivot, angle);
}
field.position.Rotation = angle;
AdjustPos(field);
}
public void BasicRotationAndOffset(float offset)
{
Quaternion target = RotationWithoutOffsetFromSpline(offset);
target = target * Quaternion.Euler(_offsetRotation);
_toMove.rotation = ExtRotation.OwnSmoothDamp(_toMove.rotation, target, ref _refRotationVelocity, _dampingTimeRotation);
}
private void DrawDirectionnalCylinder(Color color, Vector3 upCone, Vector3 choosenDirection)
{
Quaternion realdirection = ExtRotation.TurretLookRotation(choosenDirection, upCone);
Vector3 realDirectionVector = realdirection * Vector3.forward;
Debug.DrawLine(_p2 + realDirectionVector * _realRadius, _p1 + realDirectionVector * _realRadius, color);
Debug.DrawLine(_p2 - realDirectionVector * _realRadius, _p1 - realDirectionVector * _realRadius, color);
}
public virtual void UpdateRotation()
{
if (_rotateAlongSpline)
{
Quaternion target = _spline.EvaluateOrientationAtUnit(PathPosition, PositionUnits);
target = target * Quaternion.Euler(_offsetRotation);
_toMove.rotation = ExtRotation.OwnSmoothDamp(_toMove.rotation, target, ref _refRotationVelocity, _dampingTimeRotation);
}
ApplyKeepUp();
}
/// <summary>
/// draw a disc
/// </summary>
public static GravityOverrideDisc DrawDisc(ExtCircle circle, GravityOverrideDisc discGravity, Color color, bool allowBottom, out bool hasChanged)
{
hasChanged = false;
Quaternion rotation = ExtRotation.QuaternionFromVectorDirector(circle.Normal, Vector3.up);
bool topFace = discGravity.Face;
bool topExtremity = discGravity.Borders;
bool isCameraViewBehindFace = Vector3.Dot(ExtSceneView.GetSceneViewCameraTransform().forward, circle.Normal) > 0 && !allowBottom;
Handles.color = color;
if (!Event.current.alt && Event.current.button != 2 && Handles.Button(circle.Point,
rotation,
circle.Radius,
circle.Radius, Handles.CircleHandleCap))
{
Debug.Log("extremity pressed");
discGravity.Borders = !discGravity.Borders;
hasChanged = true;
Use();
}
if (!topFace)
{
Handles.color = (isCameraViewBehindFace) ? new Color(color.r, color.g, color.b, color.a / 2) : color;
Handles.DrawSolidDisc(circle.Point, circle.Normal, circle.Radius / 10 * 8);
}
if (!topExtremity)
{
Handles.color = (isCameraViewBehindFace) ? new Color(color.r, color.g, color.b, color.a / 2) : color;
ExtHandle.DrawCircleThickness(circle, 50, ExtHandle.DrawOutlineType.INSIDE);
}
Handles.color = Color.red;
if (!Event.current.alt && Event.current.button != 2 && Handles.Button(circle.Point,
rotation,
circle.Radius / 10 * 7,
circle.Radius / 10 * 7, Handles.CircleHandleCap))
{
if (isCameraViewBehindFace)
{
Debug.Log("not behind face");
}
else
{
Debug.Log("Face pressed !");
discGravity.Face = !discGravity.Face;
hasChanged = true;
Use();
}
}
return(discGravity);
}
private Quaternion GetLastDesiredRotation(Vector3 dirRelativeInput, Vector3 up)
{
//Vector3 relativeDirection = entityAction.GetRelativeDirection().normalized;
// Preserve our current up direction
// (or you could calculate this as the direction away from the planet's center)
//Vector3 up = objectToRotate.up;
//Vector3 up = baseGravity.GetMainAndOnlyGravity();
// Form a rotation facing the desired direction while keeping our
// local up vector exactly matching the current up direction.
return(ExtRotation.TurretLookRotation(dirRelativeInput, up));
}
private void SetOrientationRotation()
{
Vector3 relativeDirectionPlayer = objectToRotate.forward;
Vector3 relativeInputPlayer = entityAction.GetRelativeDirection();
Vector3 relativeDirectionCamera = entityAction.GetMainReferenceForwardDirection();
Vector3 relativeUp = entityAction.GetMainReferenceUpDirection();
CameraFromPlayerOrientation = ExtRotation.IsForwardBackWardRightLeft(objectToRotate.forward, entityAction.GetMainReferenceForwardDirection(), entityAction.GetMainReferenceUpDirection());
InputFromPlayerOrientation = ExtRotation.IsForwardBackWardRightLeft(objectToRotate.forward, relativeInputPlayer, entityAction.GetMainReferenceUpDirection());
InputFromCameraOrientation = ExtRotation.IsForwardBackWardRightLeft(relativeDirectionCamera, relativeInputPlayer, entityAction.GetMainReferenceUpDirection());
}
/// <summary>
/// get the relative direction
/// </summary>
/// <returns></returns>
public Vector3 GetRelativeDirectionWithNoDamping(Vector3 mainGravity, Vector3 debugPos, float xBoost = 1, float yBoost = 1)
{
//Vector3 noDampingForward = -Vector3.Cross(mainGravity, mainReferenceObjectDirection.right);
Vector3 relativeDirection = GetRelativeDirection();
Vector3 noDampingInputDir = ExtRotation.TurretLookRotationVector(relativeDirection, mainGravity);
Debug.DrawRay(debugPos, relativeDirection * 10, Color.black);
Debug.DrawRay(debugPos, mainGravity * 10, Color.red);
Debug.DrawRay(debugPos, noDampingInputDir * 10, Color.green);
return(noDampingInputDir);
}
private void ApplyChange()
{
//_camera.transform.position = _follow.position;
//_camera.transform.LookAt(_lookAt, _upReference.up);
_camera.transform.position = ExtVector3.OwnSmoothDamp(_camera.transform.position, _follow.position, ref _refPositionVelocity, _dampingPosition, Mathf.Infinity, Time.deltaTime);
Quaternion targetRotation = Quaternion.LookRotation(_lookAt.position - _camera.transform.position, _upReference.up);
//target = target * Quaternion.Euler(_offsetRotation);
_camera.transform.rotation = ExtRotation.OwnSmoothDamp(_camera.transform.rotation, targetRotation, ref _refRotationVelocity, _dampingLookAt, Time.deltaTime);
}
/// 2 ------2------ 3
/// 1 | 3 |
/// 1 ------4----- 4 |
/// | | 3 | |
/// | 4| | 2 |
/// | 1 |
/// | |
///
public ExtQuad(Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4) : this()
{
_position = ExtVector3.GetMeanOfXPoints(p1, p2, p3, p4);
Vector3 x = p1 - p2;
Vector3 y = p1 - p4;
Vector3 up = Vector3.Cross(x, y);
_rotation = ExtRotation.QuaternionFromVectorDirector(up, x.FastNormalized());
_rotation = ExtRotation.RotateQuaternion(_rotation, new Vector3(-90, 0, 0));
_localScale = new Vector3(y.magnitude, 1, x.magnitude);
UpdateMatrix();
}
//
public static int xGetAngleFlip(string rot, out bool mirror)
{
ExtRotation extRot = ExtRotation.Parse(rot);
int result = (int)extRot.Rotation;
if (extRot.Mirror)
{
result = (result + 180) % 360;
}
mirror = extRot.Mirror;
return(result);
}
public static RectangleF ConvertRect_mm(string x1, string y1, string x2, string y2, string rot)
{
PointF p1 = StrToPoint_mm(x1, y1);
PointF p2 = StrToPoint_mm(x2, y2);
ExtRotation rotation = ExtRotation.Parse(rot);
PointF mid = new PointF((p1.X + p2.X) / 2, (p1.Y + p2.Y) / 2);
p1 = p1.RotateAt(mid, rotation.Rotation);
p2 = p2.RotateAt(mid, rotation.Rotation);
p1 = p1.FlipX();
p2 = p2.FlipX();
RectangleF rect = new RectangleF(
Math.Min(p1.X, p2.X), Math.Min(p1.Y, p2.Y),
Math.Abs(p2.X - p1.X), Math.Abs(p2.Y - p1.Y));
return(rect);
}
public ExtCylinder(Vector3 p1, Vector3 p2, float radius = 0.25f) : this()
{
_position = ExtVector3.GetMeanOfXPoints(p1, p2);
_rotation = ExtQuaternion.QuaternionFromLine(p1, p2, Vector3.up);
_rotation = ExtRotation.RotateQuaternion(_rotation, new Vector3(90, 0, 0));
_localScale = new Vector3(1, 1, 1);
_cylinderMatrix = Matrix4x4.TRS(_position, _rotation, _localScale * 1);
//why radius a 0.25, and lenght * 0.8 ?? I don't know,
//it's there to match the first constructor(position, rotation, scale)
_radius = radius;
_lenght = ExtVector3.Distance(p2, p1) * 0.8f;
_lenghtSquared = _lenght * _lenght;
_radiusSquared = _radius * _radius;
_realRadius = _radius * MaxXY(_localScale);
_realSquaredRadius = _realRadius * _realRadius;
UpdateMatrix();
}
// NB this is for footprint texts
// pos is in KiCad coord space
// result is in KiCad coord space
// side-effect : rot.Rotation is set to KiCad text angle
public static PointF GetTextPos(PointF pos, SizeF textSize, ExtRotation rot, Align align_from, Align align_to)
{
PointF result;
PointF offset;
PointF from_offset = GetOffset(align_from, textSize);
PointF to_offset = GetOffset(align_to, textSize);
if (rot.Mirror)
{
offset = new PointF(from_offset.X - to_offset.X, from_offset.Y - to_offset.Y);
if ((rot.Rotation >= 90) && (rot.Rotation < 270))
{
offset = new PointF(from_offset.X - textSize.Width + to_offset.X, from_offset.Y - textSize.Height + to_offset.Y);
}
offset = offset.Rotate(-FlipAngleY(rot.Rotation));
result = new PointF(pos.X - offset.X, pos.Y - offset.Y);
rot.Rotation = FlipAngleY(rot.Rotation);
}
else
{
offset = new PointF(from_offset.X - to_offset.X, from_offset.Y - to_offset.Y);
// ************** this works don't change it! **************
if ((rot.Rotation > 90) && (rot.Rotation <= 270))
{
offset = new PointF(from_offset.X - textSize.Width + to_offset.X, from_offset.Y - textSize.Height + to_offset.Y);
}
result = new PointF(pos.X - offset.X, pos.Y + offset.Y);
result = result.RotateAt(pos, -rot.Rotation);
// ************** this works don't change it! **************
}
return(result);
}
private void Update()
{
if (OverrideRotationUpGlobal)
{
if (!RotateWithTheParent)
{
ToLock.rotation = ExtRotation.TurretLookRotation(_saveRotation * Vector3.forward, Vector3.up);
}
else
{
ToLock.rotation = ExtRotation.TurretLookRotation(ToLock.forward, Vector3.up);
}
_saveRotation = ToLock.rotation;
}
if (RotateWithTheParent)
{
_saveRotation = ToLock.rotation;
}
else
{
ToLock.rotation = _saveRotation;
}
}
// [MSR]0 to 359.9
public static int GetAngle(string rot)
{
int result = (int)ExtRotation.Parse(rot).Rotation;
return(result);
}
public bool ConvertBoardFile(string SourceFilename, string OutputFolder, string ProjectName)
{
bool result = false;
int net_index = 1;
DesignRules designRules = new DesignRules();
PartMap = new RenameMap();
k.LayerDescriptor layer;
Trace(string.Format("Reading board file {0}", SourceFilename));
board = EagleFile.LoadFromXmlFile(SourceFilename);
//
if (board != null)
{
libraryConverter = new LibraryConverter(Parent);
ConvertComponentLibraries(OutputFolder, false);
k.Pcb.kicad_pcb k_pcb = new k.Pcb.kicad_pcb();
k_pcb.Modules = new List <k.ModuleDef.Module>();
k_pcb.Drawings = new List <k.Pcb.graphic_base>();
// paper and size: get the page size
PageStr = "A4";
PageSize = new SizeF(297, 210);
foreach (Element element in board.Drawing.Board.Elements.Element)
{
//
if (element.Library == "frames")
{
//todo:
//ConvertFrame(element.Package);
break;
}
}
k_pcb.Page = PageStr;
// offset from bottom left
DrawingOffset = new PointF(2 * Common.inch_to_mm, 2 * Common.inch_to_mm);
k_pcb.Setup.grid_origin = StrToPoint_Board("0", "0");
//testFont(k_pcb); // ** debug
// get list of part names
foreach (Element element in board.Drawing.Board.Elements.Element)
{
PartMap.Add(element.Name);
}
PartMap.Annotate();
// layers?
#region ==== designrules ====
foreach (Param param in board.Drawing.Board.Designrules.Param)
{
designRules.Add(param.Name, param.Value);
}
#endregion
#region ==== Plain - text ====
foreach (Text text in board.Drawing.Board.Plain.Text)
{
bool mirror;
int angle = Common.xGetAngleFlip(text.Rot, out mirror);
layer = ConvertLayer(text.Layer);
if (layer != null)
{
k.Pcb.gr_text k_text = new k.Pcb.gr_text(
text.mText,
StrToPoint_Board(text.X, text.Y),
layer.Name,
new SizeF(Common.StrToVal_mm(text.Size), Common.StrToVal_mm(text.Size)),
Common.GetTextThickness_mm(text),
angle
);
k_text.effects.horiz_align = k.TextJustify.left;
SizeF textSize = strokeFont.GetTextSize(text.mText, k_text.effects);
PointF offset = new PointF(textSize.Width / 2, textSize.Height / 2);
// TODO: spin
switch ((int)ExtRotation.Parse(text.Rot).Rotation)
{
case 0:
if (mirror)
{
k_text.Position.At.Y -= offset.Y;
}
else
{
k_text.Position.At.Y -= offset.Y;
}
break;
case 90:
if (mirror)
{
k_text.Position.At.X += offset.Y;
k_text.Position.At.Y -= textSize.Width;
}
else
{
k_text.Position.At.X -= offset.Y;
}
break;
case 180:
if (mirror)
{
k_text.Position.At.Y += offset.Y;
}
else
{
k_text.Position.At.Y += textSize.Height;
}
break;
case 270:
if (mirror)
{
k_text.Position.At.X -= offset.Y;
k_text.Position.At.Y += textSize.Width;
}
else
{
k_text.Position.At.X += offset.Y;
}
break;
}
k_pcb.Drawings.Add(k_text);
}
}
#endregion
#region ==== Plain - lines ====
foreach (Wire wire in board.Drawing.Board.Plain.Wire)
{
layer = ConvertLayer(wire.Layer);
if (layer != null)
{
float width = Common.StrToVal_mm(wire.Width);
//todo: arcs
k.Pcb.gr_line k_line = new k.Pcb.gr_line(
StrToPoint_Board(wire.X1, wire.Y1), StrToPoint_Board(wire.X2, wire.Y2),
layer.Name,
width
);
k_pcb.Drawings.Add(k_line);
}
}
#endregion
#region ==== Plain - rectangle ====
// convert to unconnected zones
foreach (EagleImport.Rectangle rect in board.Drawing.Board.Plain.Rectangle)
{
layer = ConvertLayer(rect.Layer);
if (layer != null)
{
PointF p1 = StrToPoint_Board(rect.X1, rect.Y1);
PointF p2 = StrToPoint_Board(rect.X2, rect.Y2);
k.Pcb.Zone zone = new k.Pcb.Zone();
zone.layer = layer.Name;
zone.net = 0;
zone.net_name = "";
zone.hatch_pitch = 0.508f;
zone.connect_pads_clearance = 0.508f;
zone.min_thickness = 0.001f;
zone.is_filled = false;
zone.fill_arc_segments = 16;
zone.fill_thermal_gap = 0.508f;
zone.fill_thermal_bridge_width = 0.508f;
zone.polygon.Add(new PointF(p1.X, p1.Y));
zone.polygon.Add(new PointF(p2.X, p1.Y));
zone.polygon.Add(new PointF(p2.X, p2.Y));
zone.polygon.Add(new PointF(p1.X, p2.Y));
k_pcb.Zones.Add(zone);
// todo : not needed?
//k.Pcb.gr_line k_line;
//k_line = new k.Pcb.gr_line(new PointF(p1.X, p1.Y), new PointF(p2.X, p1.Y), layer.Name, width);
//k_pcb.Drawings.Add(k_line);
//k_line = new k.Pcb.gr_line(new PointF(p2.X, p1.Y), new PointF(p2.X, p2.Y), layer.Name, width);
//k_pcb.Drawings.Add(k_line);
//k_line = new k.Pcb.gr_line(new PointF(p1.X, p2.Y), new PointF(p2.X, p2.Y), layer.Name, width);
//k_pcb.Drawings.Add(k_line);
//k_line = new k.Pcb.gr_line(new PointF(p1.X, p1.Y), new PointF(p1.X, p2.Y), layer.Name, width);
//k_pcb.Drawings.Add(k_line);
}
}
#endregion
#region ==== Plain - Hole ====
foreach (Hole hole in board.Drawing.Board.Plain.Hole)
{
PointF p1 = StrToPoint_Board(hole.X, hole.Y);
float drill = Common.StrToVal_mm(hole.Drill);
k_pcb.AddModule(NonplatedHole(drill, drill), p1);
}
#endregion
#region ==== plain.dimension ====
foreach (Dimension dim in board.Drawing.Board.Plain.Dimension)
{
layer = ConvertLayer(dim.Layer);
if (layer != null)
{
PointF p1 = StrToPoint_Board(dim.X1, dim.Y1);
PointF p2 = StrToPoint_Board(dim.X2, dim.Y2);
PointF p3 = StrToPoint_Board(dim.X3, dim.Y3);
float line_width = 0.15f; // default width?
float text_size = Common.StrToVal_mm(dim.TextSize);
float text_width = Common.GetTextThickness_mm(dim.TextSize, dim.TextRatio);
if (!string.IsNullOrEmpty(dim.Width))
{
line_width = Common.StrToVal_mm(dim.Width);
}
switch (dim.Dtype)
{
case DimensionType.parallel:
case DimensionType.radius:
case DimensionType.diameter:
k.Pcb.Dimension k_dim = new k.Pcb.Dimension(layer.Name, line_width, p1, p2, text_size, text_width,
dim.Unit == GridUnit.mm, int.Parse(dim.Precision), dim.Visible == Bool.yes);
k_pcb.Dimensions.Add(k_dim);
break;
//todo : others?
}
}
}
#endregion
#region ==== plain.polygon ====
foreach (EagleImport.Polygon poly in board.Drawing.Board.Plain.Polygon)
{
//todo
// if layer is tRestrict or bRestrict, create a keepout zone
if ((poly.Layer == "41") || (poly.Layer == "42"))
{
k.Pcb.Zone zone = new k.Pcb.Zone();
if (poly.Layer == "41")
{
zone.layer = k.LayerList.StandardLayers.GetLayerName(k.Layer.nFront_Cu);
}
else if (poly.Layer == "42")
{
zone.layer = k.LayerList.StandardLayers.GetLayerName(k.Layer.nBack_Cu);
}
zone.net = 0;
zone.net_name = "";
zone.hatch_pitch = 0.508f;
zone.connect_pads_clearance = 0;
zone.min_thickness = 10.0f;
zone.is_filled = false;
zone.fill_arc_segments = 16;
zone.connect_pads_mode = k.Pcb.ZonePadConnection.yes; //solid
zone.fill_thermal_gap = 0.508f;
zone.fill_thermal_bridge_width = 0.508f;
zone.is_keepout = true;
zone.outline_style = k.Pcb.ZoneOutlineStyle.none;
zone.keepout_allow_copper_pour = Kicad_utils.Allowed.not_allowed;
zone.priority = 7;
foreach (Vertex v in poly.Vertex)
{
zone.polygon.Add(StrToPoint_Board(v.X, v.Y));
}
k_pcb.Zones.Add(zone);
}
}
#endregion
#region ==== Signals ====
// get net list
foreach (Signal signal in board.Drawing.Board.Signals.Signal)
{
//todo: ?
k_pcb.Nets.Add(new k.Pcb.Net(net_index, signal.Name));
net_index++;
}
List <PinConnection> Contacts = new List <PinConnection>();
foreach (Signal signal in board.Drawing.Board.Signals.Signal)
{
//todo: ?
k.Pcb.Net k_net = k_pcb.Nets.Find(x => x.Name == signal.Name);
foreach (Wire wire in signal.Wire)
{
layer = ConvertLayer(wire.Layer);
if (layer != null)
{
// todo: segment must be on a copper layer?
// ignore unrouted
if (wire.Layer != "19")
{
float width = Common.StrToVal_mm(wire.Width);
//todo: arcs?
k.Pcb.PcbSegment seg = new Kicad_utils.Pcb.PcbSegment();
seg.layer = layer.Name;
seg.net = k_net.Number;
seg.start = StrToPoint_Board(wire.X1, wire.Y1);
seg.end = StrToPoint_Board(wire.X2, wire.Y2);
seg.width = width;
k_pcb.Segments.Add(seg);
Contacts.Add(new PinConnection(signal.Name, seg.start, layer.Name, null, null));
Contacts.Add(new PinConnection(signal.Name, seg.end, layer.Name, null, null));
}
}
}
// contactref
foreach (Contactref con_ref in signal.Contactref)
{
Contacts.Add(new PinConnection(signal.Name, PointF.Empty, null, con_ref.Element, con_ref.Pad));
}
//<via x="6.6675" y="49.2125" extent="1-16" drill="0.3" shape="octagon"/>
foreach (Via via in signal.Via)
{
float drill = Common.StrToVal_mm(via.Drill);
PointF pos = StrToPoint_Board(via.X, via.Y);
float size = Common.StrToVal_mm(via.Diameter);
if (size == 0)
{
size = designRules.CalcViaSize(drill);
}
k.Pcb.Via k_via = new k.Pcb.Via(pos, size, drill,
k.LayerList.StandardLayers.GetLayerName(k.Layer.nFront_Cu),
k.LayerList.StandardLayers.GetLayerName(k.Layer.nBack_Cu),
k_net.Number);
PinConnection p_conn = Contacts.Find(x => x.position.X == k_via.at.X && x.position.Y == k_via.at.Y);
if (via.Extent == "1-16")
{
k_via.topmost_layer = k.LayerList.StandardLayers.GetLayerName(k.Layer.nFront_Cu);
k_via.backmost_layer = k.LayerList.StandardLayers.GetLayerName(k.Layer.nBack_Cu);
}
else
{
Trace(string.Format("error : blind/buried via ? {0},{1} {2} {3}", via.X, via.Y, signal.Name, via.Extent));
}
if (p_conn == null)
{
Trace(string.Format("note : loose via converted to pad at {0},{1} net={2}", via.X, via.Y, signal.Name));
k.ModuleDef.Module k_pad = ViaPad(size, drill, k_net);
k_pcb.AddModule(k_pad, pos);
}
else
{
k_pcb.Vias.Add(k_via);
}
}
foreach (EagleImport.Polygon poly in signal.Polygon)
{
//<polygon width="0.2032" layer="1" spacing="0.254" isolate="0.254" rank="2">
//defaults are 6 mil
float width = 0.1524f;
float isolate = 0.1524f;
float spacing = 0.1524f;
int rank = int.Parse(poly.Rank);
layer = ConvertLayer(poly.Layer);
if (layer != null)
{
//todo: clearances etc should come from DesignRules?
if (!string.IsNullOrEmpty(poly.Width))
{
width = Common.StrToVal_mm(poly.Width);
}
if (!string.IsNullOrEmpty(poly.Isolate))
{
isolate = Common.StrToVal_mm(poly.Isolate);
}
if (!string.IsNullOrEmpty(poly.Spacing))
{
spacing = Common.StrToVal_mm(poly.Spacing);
}
if (k.Layer.IsCopperLayer(layer.Number) || (poly.Layer == "41") || (poly.Layer == "42"))
{
k.Pcb.Zone zone = new k.Pcb.Zone();
if (poly.Layer == "41")
{
zone.layer = k.LayerList.StandardLayers.GetLayerName(k.Layer.nFront_Cu);
}
else if (poly.Layer == "42")
{
zone.layer = k.LayerList.StandardLayers.GetLayerName(k.Layer.nBack_Cu);
}
else
{
zone.layer = layer.Name;
}
zone.net = k_net.Number;
zone.net_name = k_net.Name;
zone.outline_style = k.Pcb.ZoneOutlineStyle.edge;
zone.hatch_pitch = 0.508f;
zone.connect_pads_clearance = 0.2032f;
zone.min_thickness = width; // ??
zone.fill_arc_segments = 32;
zone.fill_thermal_gap = 0.2032f;
zone.fill_thermal_bridge_width = 0.2032f;
zone.is_filled = false;
foreach (Vertex v in poly.Vertex)
{
zone.polygon.Add(StrToPoint_Board(v.X, v.Y));
}
if ((poly.Pour == PolygonPour.cutout) ||
!k.Layer.IsCopperLayer(layer.Number))
{
zone.is_keepout = true;
zone.outline_style = k.Pcb.ZoneOutlineStyle.none;
zone.keepout_allow_copper_pour = Kicad_utils.Allowed.not_allowed;
}
if (!string.IsNullOrEmpty(poly.Isolate))
{
zone.connect_pads_clearance = isolate;
}
if (poly.Thermals == Bool.yes)
{
zone.connect_pads_mode = k.Pcb.ZonePadConnection.thermal_relief;
zone.fill_thermal_gap = width + 0.001f; // **
zone.fill_thermal_bridge_width = width + 0.001f; // **
}
else
{
zone.connect_pads_mode = k.Pcb.ZonePadConnection.yes;
}
// priority on KiCad is opposite to rank
zone.priority = 6 - rank;
k_pcb.Zones.Add(zone);
}
}
}
//
}
#endregion
#region ==== Elements ====
foreach (Element element in board.Drawing.Board.Elements.Element)
{
//todo:
k.ModuleDef.Module k_mod;
// find package library : package
string footprint_sid = element.Library + ":" + libraryConverter.FootprintNameMap.GetNewName(element.Package);
k.ModuleDef.Module k_template = libraryConverter.AllFootprints.Find(x => x.Name == footprint_sid);
if (k_template == null)
{
Trace(string.Format("error: {0} not found", footprint_sid));
}
else
{
k_mod = k_template.Clone(true);
k_mod.Name = footprint_sid;
k_mod.Reference.Value = PartMap.GetNewName(element.Name);
k_mod.At = StrToPoint_Board(element.X, element.Y);
if (k_mod.Value != null)
{
k_mod.Value.Value = element.Value;
}
k_mod.layer = k.LayerList.StandardLayers.GetLayerName(k.Layer.nFront_Cu);
// Set position, orientation
ExtRotation elementRot = ExtRotation.Parse(element.Rot);
int element_angle = (int)elementRot.Rotation;
// get attributes for text
foreach (EagleImport.Attribute attrib in element.Attribute)
{
ExtRotation attrRot = ExtRotation.Parse(attrib.Rot);
bool attr_mirror = attrRot.Mirror;
int attr_angle = (int)attrRot.Rotation;
layer = ConvertLayer(attrib.Layer);
if (layer != null)
{
//k.Symbol.SymbolField sym_field = null;
k.ModuleDef.fp_text field = null;
switch (attrib.Name)
{
case "NAME":
//sym_field = k_symbol.fReference;
field = k_mod.Reference;
break;
case "VALUE":
//sym_field = k_symbol.fValue;
field = k_mod.Value;
break;
// Part?
// voltage, current
}
if (field != null)
{
field.effects.font.Size = new SizeF(Common.StrToVal_mm(attrib.Size), Common.StrToVal_mm(attrib.Size));
field.layer = layer.Name;
field.layer = k.Layer.MakeLayerName(k_mod.layer, field.layer);
//field.effects.horiz_align = k.TextJustify.left;
//field.effects.vert_align = k.VerticalAlign.bottom;
SetPcbTextAttributes(field,
StrToPoint_Board(element.X, element.Y), elementRot,
StrToPoint_Board(attrib.X, attrib.Y), attrRot);
// AdjustPos(field);
//debug
if (pcb_debug)
{
PointF ptext = new PointF(field.position.At.X, field.position.At.Y);
SizeF textSize = strokeFont.GetTextSize(field.Value, field.effects);
if (elementRot.Mirror)
{
// get bottom right
ptext.X += textSize.Width / 2;
ptext.Y += textSize.Height / 2;
ptext = ptext.Rotate(-elementRot.Rotation - 180);
ptext.Y = -ptext.Y;
}
else
{
// get bottom left
ptext.X -= textSize.Width / 2;
ptext.Y += textSize.Height / 2;
ptext = ptext.Rotate(-elementRot.Rotation);
}
ptext = k_mod.position.At.Add(ptext);
//!DrawRect(k_pcb, ptext, textSize, -(elementRot.Rotation + field.position.Rotation));
//
PointF p1 = new PointF(field.position.At.X, field.position.At.Y);
k.Pcb.gr_line k_line;
float ds = 1.27f;
if (elementRot.Mirror)
{
p1 = p1.Rotate(-elementRot.Rotation - 180);
p1.Y = -p1.Y;
}
else
{
p1 = p1.Rotate(-elementRot.Rotation);
}
//p1 = p1.Rotate(field.position.Rotation);
//p1 = p1.Rotate(k_mod.position.Rotation);
k_line = new k.Pcb.gr_line(
new PointF(k_mod.position.At.X + p1.X - ds, k_mod.position.At.Y + p1.Y),
new PointF(k_mod.position.At.X + p1.X + ds, k_mod.position.At.Y + p1.Y), "Dwgs.User", 0.01f);
k_pcb.Drawings.Add(k_line);
k_line = new k.Pcb.gr_line(
new PointF(k_mod.position.At.X + p1.X, k_mod.position.At.Y + p1.Y - ds),
new PointF(k_mod.position.At.X + p1.X, k_mod.position.At.Y + p1.Y + ds), "Dwgs.User", 0.01f);
k_pcb.Drawings.Add(k_line);
}
}
}
}
// Note: the Eagle "mirror" attribute reverses side and flips about Y | axis, but
// Kicad "flip" reverses side and flips about X -- axis.
// therefore Eagle mirror is equivalent to Kicad flip + rotate(180)
if (elementRot.Mirror)
{
k_mod.RotateBy(MathUtil.NormalizeAngle(-(element_angle + 180)));
k_mod.FlipX(k_mod.position.At);
}
else //if (element_angle != 0)
{
k_mod.RotateBy(element_angle);
}
// fix up pads
foreach (k.ModuleDef.pad pad in k_mod.Pads)
{
string new_name = PartMap.GetNewName(element.Name);
if (pad.type != k.ModuleDef.pad.nonplated_hole)
{
PinConnection contact = Contacts.Find(x => x.PartName == element.Name && x.PinName == pad.number);
if (contact == null)
{
// may actually be a non-connect
// Trace(string.Format("warning: contact {0} {1} not found", element.Name, pad.number));
}
else
{
pad.net = k_pcb.Nets.Find(x => x.Name == contact.NetLabel);
}
}
}
//
k_pcb.Modules.Add(k_mod);
}
}
#endregion
// transfer some design rules
k_pcb.Setup.trace_min = designRules.GetValueFloat("msWidth");
k_pcb.Setup.via_min_size = designRules.GetValueFloat("msWidth");
k_pcb.Setup.via_min_drill = designRules.GetValueFloat("msDrill");
k_pcb.Setup.uvia_min_size = designRules.GetValueFloat("msMicroVia");
k_pcb.Setup.uvia_min_drill = designRules.GetValueFloat("msMicroVia"); // not right, but need layer thickness to calculate correctly
// allow uvia
// allow blind/buried via
// grid
// text and drawings
// pad
// pad mask clearance
//default netclass
k_pcb.NetClasses[0].clearance = designRules.GetValueFloat("mdPadVia");
k_pcb.NetClasses[0].trace_width = designRules.GetValueFloat("msWidth");
k_pcb.NetClasses[0].via_dia = designRules.GetValueFloat("msWidth");
k_pcb.NetClasses[0].via_drill = designRules.GetValueFloat("msDrill");
k_pcb.NetClasses[0].uvia_dia = designRules.GetValueFloat("msMicroVia");
k_pcb.NetClasses[0].uvia_drill = designRules.GetValueFloat("msMicroVia"); // not right
// write the KiCad file
string filename = Path.Combine(OutputFolder, ProjectName + ".kicad_pcb");
Trace(string.Format("Writing board {0}", filename));
k_pcb.SaveToFile(filename);
result = true;
}
else
{
result = false;
Trace(string.Format("error opening {0}", SourceFilename));
}
return(result);
}
//here get the acceleration forward depending on the gravity
public Vector3 GetActualDirForward()
{
Quaternion forwardDir = ExtRotation.TurretLookRotation(GetActualVelocityVector(), baseGravity.GetMainAndOnlyGravity());
return(forwardDir * Vector3.forward);
}
public bool ConvertLibrary(string LibName, Library lib, List <Layer> layers, string OutputFolder, bool WriteLibFile)
{
string lib_filename;
k.LayerDescriptor layer;
Trace("Processing Library: " + LibName);
Layers = layers;
// Packages
k.ModuleDef.LibModule k_footprint_lib = new Kicad_utils.ModuleDef.LibModule();
k_footprint_lib.Name = LibName;
foreach (Package package in lib.Packages.Package)
{
k.ModuleDef.Module k_module = new Kicad_utils.ModuleDef.Module();
k_module.Name = Common.CleanFootprintName(package.Name);
FootprintNameMap.Add(package.Name, k_module.Name);
if (package.Name != k_module.Name)
{
Trace(String.Format("note: {0} is renamed to {1}", package.Name, k_module.Name));
}
if (package.Description != null)
{
k_module.description = Common.CleanTags(package.Description.Text);
}
k_module.position = new k.Position(0, 0, 0);
k_module.layer = "F.Cu"; // todo: back ???
foreach (Wire wire in package.Wire)
{
layer = ConvertLayer(wire.Layer, package.Name);
if (layer != null)
{
//
float curve = (float)StringUtils.StringToDouble(wire.Curve);
if (curve == 0)
{
k.ModuleDef.fp_line k_line = new Kicad_utils.ModuleDef.fp_line(
Common.StrToPointFlip_mm(wire.X1, wire.Y1),
Common.StrToPointFlip_mm(wire.X2, wire.Y2),
layer.Name,
Common.StrToVal_mm(wire.Width));
k_module.Borders.Add(k_line);
}
else
{
PointF start = Common.StrToPointFlip_mm(wire.X1, wire.Y1);
PointF end = Common.StrToPointFlip_mm(wire.X2, wire.Y2);
float arc_start, arc_end, radius;
PointF center = Common.kicad_arc_center(start, end, curve, out radius, out arc_start, out arc_end);
k.ModuleDef.fp_arc k_arc = new k.ModuleDef.fp_arc(
center, start,
-curve,
layer.Name,
Common.StrToVal_mm(wire.Width));
k_module.Borders.Add(k_arc);
}
}
}
foreach (Smd smd in package.Smd)
{
float roundness = Common.StrToVal(smd.Roundness, 0);
string shape = "rect";
if (roundness == 100)
{
shape = "oval";
}
k.ModuleDef.pad k_pad = new k.ModuleDef.pad(smd.Name, "smd", shape, Common.StrToPointFlip_mm(smd.X, smd.Y), Common.StrToSize_mm(smd.Dx, smd.Dy), 0);
if (Common.GetAngle(smd.Rot) % 180 == 90)
{
k_pad.size = Common.StrToSize_mm(smd.Dy, smd.Dx);
}
if (smd.Stop == Bool.no)
{
k_pad._layers.RemoveLayer("F.Mask");
}
if (smd.Cream == Bool.no)
{
k_pad._layers.RemoveLayer("F.Paste");
}
k_module.Pads.Add(k_pad);
}
foreach (Pad pad in package.Pad)
{
float pad_size = Common.StrToVal_mm(pad.Diameter);
if (pad_size == 0)
{
pad_size = designRules.CalcPadSize(Common.StrToVal_mm(pad.Drill));
}
k.ModuleDef.pad k_pad = new k.ModuleDef.pad(pad.Name, "thru_hole", "circle",
Common.StrToPointFlip_mm(pad.X, pad.Y), new SizeF(pad_size, pad_size), Common.StrToVal_mm(pad.Drill));
if (pad.Stop == Bool.no)
{
k_pad._layers.RemoveLayer("F.Mask");
k_pad._layers.RemoveLayer("B.Mask");
}
if (pad.Thermals == Bool.no)
{
k_pad.thermal_gap = 0;
}
if (pad.Shape == PadShape.@long)
{
k_pad.shape = "oval";
if (Common.GetAngle(pad.Rot) % 180 == 0)
{
k_pad.size = new SizeF(pad_size * 2, pad_size);
}
else
{
k_pad.size = new SizeF(pad_size, pad_size * 2);
}
}
k_module.Pads.Add(k_pad);
}
foreach (Text text in package.Text)
{
PointF pos = Common.StrToPointFlip_mm(text.X, text.Y);
layer = ConvertLayer(text.Layer, package.Name);
if (layer != null)
{
k.ModuleDef.fp_text k_text = new k.ModuleDef.fp_text("ref", text.mText,
pos,
layer.Name,
new SizeF(Common.StrToVal_mm(text.Size), Common.StrToVal_mm(text.Size)),
Common.GetTextThickness_mm(text),
true);
// TODO: adjust position for center, center alignment
ExtRotation rot = ExtRotation.Parse(text.Rot);
SizeF textSize = strokeFont.GetTextSize(text.mText, k_text.effects);
k_text.position.At = Common.GetTextPos(pos, textSize, rot, text.Align, Align.bottom_left);
k_text.position.Rotation = rot.Rotation;
k_text.effects.vert_align = k.VerticalAlign.bottom;
k_text.effects.horiz_align = k.TextJustify.left;
if (rot.Mirror)
{
k_text.effects.mirror = true;
}
if (text.mText.StartsWith(">"))
{
string t = text.mText.ToUpperInvariant();
if (t.Contains("NAME") || t.Contains("PART"))
{
k_text.Type = "reference";
k_module.Reference = k_text;
}
else if (t.Contains("VALUE"))
{
k_text.Type = "value";
k_module.Value = k_text;
}
// user field ?
}
else
{
k_text.Type = "user";
k_module.UserText.Add(k_text);
}
}
}
foreach (EagleImport.Rectangle rect in package.Rectangle)
{
layer = ConvertLayer(rect.Layer, package.Name);
if (layer != null)
{
RectangleF r = Common.ConvertRect_mm(rect.X1, rect.Y1, rect.X2, rect.Y2, rect.Rot);
List <PointF> poly = Common.RectToPoly(r);
k.ModuleDef.fp_polygon k_poly = new Kicad_utils.ModuleDef.fp_polygon(
poly,
layer.Name,
0 // width?
);
k_module.Borders.Add(k_poly);
}
}
foreach (Circle circle in package.Circle)
{
layer = ConvertLayer(circle.Layer, package.Name);
if (layer != null)
{
float width = 0;
if (!string.IsNullOrEmpty(circle.Width))
{
width = Common.StrToVal_mm(circle.Width);
}
// if width == 0 convert to poly
if (width == 0)
{
PointF center = Common.StrToPointFlip_mm(circle.X, circle.Y);
float radius = Common.StrToVal_mm(circle.Radius);
List <PointF> pts = new List <PointF>();
int n_segments = 360 / 15;
int j = 0;
float step = 15;
while (j < n_segments)
{
float angle = MathUtil.DegToRad(j * step);
PointF p = new PointF((float)(center.X + Math.Cos(angle) * radius),
(float)(center.Y + Math.Sin(angle) * radius));
pts.Add(p);
j++;
}
k.ModuleDef.fp_polygon k_poly = new Kicad_utils.ModuleDef.fp_polygon(pts, layer.Name, width);
k_module.Borders.Add(k_poly);
}
else
{
k.ModuleDef.fp_circle k_circle = new Kicad_utils.ModuleDef.fp_circle(
Common.StrToPointFlip_mm(circle.X, circle.Y),
Common.StrToVal_mm(circle.Radius),
layer.Name,
Common.StrToVal_mm(circle.Width)
);
k_module.Borders.Add(k_circle);
}
}
}
foreach (Hole hole in package.Hole)
{
k.ModuleDef.pad k_hole = new Kicad_utils.ModuleDef.pad("", "np_thru_hole",
"circle",
Common.StrToPointFlip_mm(hole.X, hole.Y),
new SizeF(Common.StrToVal_mm(hole.Drill), Common.StrToVal_mm(hole.Drill)),
Common.StrToVal_mm(hole.Drill)
);
k_module.Pads.Add(k_hole);
}
foreach (EagleImport.Polygon poly in package.Polygon)
{
layer = ConvertLayer(poly.Layer, package.Name);
if (layer != null)
{
float width = 0;
if (!string.IsNullOrEmpty(poly.Width))
{
width = Common.StrToVal_mm(poly.Width);
}
int index = 0;
if (poly.Vertex.Count > 0)
{
List <PointF> pts = new List <PointF>();
PointF p1 = Common.StrToPoint_mm(poly.Vertex[index].X, poly.Vertex[index].Y);
float curve1 = (float)StringUtils.StringToDouble(poly.Vertex[index].Curve);
index++;
pts.Add(p1.FlipX());
while (index <= poly.Vertex.Count)
{
PointF p2 = Common.StrToPoint_mm(poly.Vertex[index % poly.Vertex.Count].X, poly.Vertex[index % poly.Vertex.Count].Y);
if (curve1 == 0)
{
if (index < poly.Vertex.Count)
{
pts.Add(p2.FlipX());
}
}
else
{
float arc_start, arc_end, radius;
PointF center = Common.kicad_arc_center2(p1, p2, curve1, out radius, out arc_start, out arc_end);
if (arc_end < arc_start)
{
arc_end += 360;
}
int n_segments = (int)((Math.Abs(arc_end - arc_start) + 7.5f) / 15f);
int j = 1;
float step = (arc_end - arc_start) / n_segments;
while (j <= n_segments)
{
float angle = MathUtil.DegToRad(arc_start + j * step);
PointF p = new PointF((float)(center.X + Math.Cos(angle) * radius),
(float)(center.Y + Math.Sin(angle) * radius));
pts.Add(p.FlipX());
j++;
}
}
p1 = p2;
if (index < poly.Vertex.Count)
{
curve1 = (float)StringUtils.StringToDouble(poly.Vertex[index].Curve);
}
index++;
}
k.ModuleDef.fp_polygon k_poly = new Kicad_utils.ModuleDef.fp_polygon(pts, layer.Name, width);
k_module.Borders.Add(k_poly);
}
}
}
//
k_footprint_lib.Modules.Add(k_module);
//
k.ModuleDef.Module k_generic = k_module.Clone();
k_generic.Name = LibName + ":" + k_generic.Name;
AllFootprints.Add(k_generic);
}
if (WriteLibFile & (k_footprint_lib.Modules.Count > 0))
{
lib_filename = Path.Combine(OutputFolder);
k_footprint_lib.WriteLibrary(lib_filename);
//! footprintTable.Entries.Add(new Kicad_utils.Project.LibEntry(LibName, "KiCad", @"$(KIPRJMOD)\\" + k_footprint_lib.Name + ".pretty", "", ""));
}
if (lib.Devicesets != null)
{
// Symbols
k.Symbol.LibSymbolLegacy kicad_lib = new k.Symbol.LibSymbolLegacy();
kicad_lib.Name = LibName;
kicad_lib.Symbols = new List <k.Symbol.Symbol>();
foreach (Deviceset devset in lib.Devicesets.Deviceset)
{
string prefix;
if (string.IsNullOrEmpty(devset.Prefix))
{
prefix = "U";
}
else
{
prefix = devset.Prefix;
}
Trace(string.Format("debug: {0}", devset.Name));
k.Symbol.Symbol k_sym = new k.Symbol.Symbol(devset.Name, true, prefix, 20, true, true, 1, false, false);
if (devset.Description != null)
{
k_sym.Description = Common.CleanTags(devset.Description.Text);
}
// prefix placeholder for reference = >NAME or >PART if multi-part?
// symbol name is placeholder for value = >VALUE
k_sym.fReference = new k.Symbol.SymbolField(prefix, new PointF(-50, 0), 50, true, "H", "L", "B", false, false);
k_sym.fValue = new k.Symbol.SymbolField(k_sym.Name, new PointF(50, 0), 50, true, "H", "L", "B", false, false);
k_sym.Drawings = new List <k.Symbol.sym_drawing_base>();
k_sym.UserFields = new List <k.Symbol.SymbolField>();
//
GetSymbol(lib, devset, k_sym);
AllSymbols.Add(k_sym);
//
if ((devset.Devices.Device.Count == 1) && (devset.Devices.Device[0].Package == null))
{
// symbol only
Trace(string.Format("debug: symbol only {0}", devset.Name));
kicad_lib.Symbols.Add(k_sym);
}
else
{
foreach (Device device in devset.Devices.Device)
{
// foreach technology
string name;
if (device.Name == "")
{
name = devset.Name;
}
else
{
name = devset.Name + device.Name;
}
k.Symbol.Symbol k_sym_device = k_sym.Clone();
k_sym_device.Name = name;
k_sym_device.fValue.Text.Value = name;
// place below value
PointF pos;
if (k_sym_device.fValue.Text.Pos.Rotation == 0)
{
pos = new PointF(k_sym_device.fValue.Text.Pos.At.X, k_sym_device.fValue.Text.Pos.At.Y - 100);
}
else
{
pos = new PointF(k_sym_device.fValue.Text.Pos.At.X + 100, k_sym_device.fValue.Text.Pos.At.Y);
}
k_sym_device.fPcbFootprint = new k.Symbol.SymbolField(kicad_lib.Name + ":" + device.Package,
pos,
50, true, k_sym_device.fValue.Text.Pos.Rotation == 0 ? "H" : "V",
"L", "B", false, false);
Trace(string.Format("debug: device {0} {1}", name, k_sym_device.fPcbFootprint.Text.Value));
// pin mapping
if (device.Connects != null)
{
foreach (Connect connect in device.Connects.Connect)
{
int unit;
if (k_sym_device.NumUnits == 1)
{
unit = 0;
}
else
{
unit = 1;
foreach (Gate gate in devset.Gates.Gate)
{
if (gate.Name == connect.Gate)
{
break;
}
else
{
unit++;
}
}
}
k.Symbol.sym_pin k_pin = k_sym_device.FindPin(unit, Common.ConvertName(connect.Pin));
if (k_pin == null)
{
Trace(string.Format("error: pin not found {0} {1}", k_sym_device.Name, connect.Pin));
}
else
{
string[] pads;
pads = connect.Pad.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
int index = 0;
foreach (string s in pads)
{
// check length
if (s.Length > 4)
{
Trace(string.Format("error: pad name too long {0} {1}", k_sym_device.Name, connect.Pad));
}
if (index == 0)
{
k_pin.PinNumber = s;
}
else
{
k.Symbol.sym_pin k_dup_pin = k.Symbol.sym_pin.Clone(k_pin);
k_dup_pin.Visible = false;
k_dup_pin.PinNumber = s;
k_sym_device.Drawings.Add(k_dup_pin);
}
index++;
}
}
}
}
// k_sym_device
bool first = true;
foreach (Technology tech in device.Technologies.Technology)
{
if (tech.Name == "")
{
if (device.Name == "")
{
name = devset.Name.Replace("*", "");
}
else
{
name = devset.Name.Replace("*", "") + device.Name;
}
k_sym_device.Name = name;
k_sym_device.fValue.Text.Value = name;
kicad_lib.Symbols.Add(k_sym_device);
AllDevices.Add(new Device(name, device.Package));
}
else
{
if (first)
{
if (device.Name == "")
{
name = devset.Name.Replace("*", tech.Name);
}
else
{
name = devset.Name.Replace("*", tech.Name) + device.Name;
}
k_sym_device.Name = name;
k_sym_device.fValue.Text.Value = name;
kicad_lib.Symbols.Add(k_sym_device);
AllDevices.Add(new Device(name, device.Package));
}
else
{
// create alias
k_sym_device.Alias.Add(devset.Name.Replace("*", tech.Name) + device.Name); // ?
}
}
first = false;
}
}
}
}
LibNames.Add(kicad_lib.Name);
//
if (WriteLibFile)
{
lib_filename = Path.Combine(OutputFolder, kicad_lib.Name + ".lib");
kicad_lib.WriteToFile(lib_filename);
}
}
return(true);
}
private void RotateUp()
{
Undo.RecordObject(_target.ToLock, "Rotate Up");
_target.ToLock.rotation = ExtRotation.TurretLookRotation(this.GetPropertie("_saveRotation").quaternionValue *Vector3.forward, Vector3.up);
}
private void ConvertSheet(k.Schema.SchematicLegacy k_schematic, int EagleSheetNumber, string DestName, bool IsMain, int SheetNumber, int NumSheets)
{
List <PinConnection> connections = new List <PinConnection>();
List <LineSegment> BusLines = new List <LineSegment>();
Trace(string.Format("Processing schematic sheet: {0}", EagleSheetNumber + 1));
Sheet source_sheet = schematic.Drawing.Schematic.Sheets.Sheet[EagleSheetNumber];
SheetLegacy k_sheet = new SheetLegacy();
k_sheet.Filename = DestName;
k_sheet.LibNames = libraryConverter.LibNames;
k_sheet.SheetNumber = SheetNumber;
k_sheet.SheetCount = NumSheets;
k_schematic.Sheets.Add(k_sheet);
if (IsMain)
{
k_schematic.MainSheet = k_sheet;
}
// first get the page size
foreach (Instance instance in source_sheet.Instances.Instance)
{
// find part ->
Part part = FindPart(instance.Part);
if (part == null)
{
continue;
}
//
if (part.Library == "frames")
{
PageStr = "A4";
PageSize = new SizeF(297, 210);
ConvertFrame(part.Deviceset);
k_sheet.PaperName = PageStr;
k_sheet.PageSize = new SizeF(PageSize.Width * Common.mm_to_mil, PageSize.Height * Common.mm_to_mil);
break;
}
}
// text items
foreach (Text text in source_sheet.Plain.Text)
{
bool mirror;
k.Schema.sch_text k_text = sch_text.CreateNote(
text.mText,
StrToPointInchFlip(text.X, text.Y),
Common.StrToInch(text.Size),
Common.xGetAngleFlip(text.Rot, out mirror),
false, false);
switch (Common.GetAngle(text.Rot))
{
case 0: break;
case 90:
if (mirror)
{
k_text.Pos.X += (int)(k_text.TextSize * 1.5f);
k_text.Pos.Y -= (int)(k_text.name.Length * k_text.TextSize * 1.5f);
}
break;
case 180:
k_text.Pos.Y += (int)(k_text.TextSize * 1.5f);
break;
case 270:
if (mirror)
{
//k_text.Pos.X += (int)(k_text.TextSize * 1.5f);
k_text.Pos.Y += (int)(k_text.name.Length * k_text.TextSize * 1.7f);
}
else
{
k_text.Pos.X += (int)(k_text.TextSize * 1.5f);
}
break;
}
k_sheet.Items.Add(k_text);
}
// lines
foreach (Wire wire in source_sheet.Plain.Wire)
{
k.Schema.sch_wire k_line = sch_wire.CreateLine(StrToPointInchFlip(wire.X1, wire.Y1),
StrToPointInchFlip(wire.X2, wire.Y2));
k_sheet.Items.Add(k_line);
}
#region === (Instance) components ====
foreach (Instance instance in source_sheet.Instances.Instance)
{
// find part ->
Part part = FindPart(instance.Part);
if (part == null)
{
Trace("error: Part not found: " + instance.Part);
continue;
}
if (part.Library == "frames")
{
continue;
}
k.Symbol.Symbol k_symbol = FindSymbol(part.Deviceset);
LegacyComponent k_comp = new LegacyComponent();
k_comp.Timestamp = GetUniqueTimeStamp();
// need to flip Y coord
k_comp.Position = StrToPointInchFlip(instance.X, instance.Y);
k_comp.Symbol = new PartSpecifier(part.Deviceset + part.Device);
// set Reference field
if (!k_symbol.PowerSymbol)
{
k_comp.Reference = PartMap.GetNewName(instance.Part);
if (instance.Part != k_comp.Reference)
{
Trace(String.Format("note: {0} is renamed {1}", instance.Part, k_comp.Reference));
}
}
else
{
k_comp.Reference = k_symbol.Reference;
k_comp.fReference.Hidden = !k_symbol.fReference.Text.Visible;
k_comp.fReference.Size = (int)k_symbol.fReference.Text.FontSize;
}
// set a default pos/
k_comp.fReference.Pos = new PointF(k_comp.Position.X + k_symbol.fReference.Text.Pos.At.X, k_comp.Position.Y + k_symbol.fReference.Text.Pos.At.Y);
k_comp.fReference.HorizJustify = "L";
k_comp.fReference.VertJustify = "B";
// Set Value field
if (!string.IsNullOrEmpty(part.Value))
{
k_comp.Value = part.Value;
}
else
{
k_comp.Value = k_symbol.fValue.Text.Value;
}
k_comp.fValue.Pos = new PointF(k_comp.Position.X + k_symbol.fValue.Text.Pos.At.X, k_comp.Position.Y + k_symbol.fValue.Text.Pos.At.Y);
k_comp.fValue.HorizJustify = "L";
k_comp.fValue.VertJustify = "B";
// Set Footprint field
Device device = libraryConverter.AllDevices.Find(x => x.Name == part.Deviceset + part.Device);
if (device != null)
{
k_comp.Footprint = part.Library + ":" + device.Package;
}
k_comp.fPcbFootprint.Pos = new PointF(k_comp.Position.X, k_comp.Position.Y);
k_comp.fPcbFootprint.Hidden = true;
// User doc field (not used)
k_comp.fUserDocLink.Pos = new PointF(k_comp.Position.X, k_comp.Position.Y);
//
if (k_symbol.NumUnits > 1)
{
int unit = GetUnitNumber(part, instance.Gate);
k_comp.N = unit;
}
// ---------------------------------
// Set position, orientation
ExtRotation instanceRot = ExtRotation.Parse(instance.Rot);
bool instance_mirror = instanceRot.Mirror;
int instance_angle = (int)instanceRot.Rotation;
if (!string.IsNullOrEmpty(instance.Rot))
{
if (instance_mirror)
{
k_comp.Rotation = (instance_angle + 180) % 360;
}
else
{
k_comp.Rotation = instance_angle;
}
k_comp.Mirror = instance_mirror;
}
foreach (EagleImport.Attribute attrib in instance.Attribute)
{
ExtRotation attrRot = ExtRotation.Parse(attrib.Rot);
bool attr_mirror = attrRot.Mirror;
int attr_angle = (int)attrRot.Rotation;
//int angle = GetAngle(attrib.Rot);
//angle %= 360;
//string orientation = (angle == 0) || (angle == 180) ? "H" : "V";
k.Symbol.SymbolField sym_field = null;
LegacyField field = null;
switch (attrib.Name)
{
case "NAME":
sym_field = k_symbol.fReference;
field = k_comp.fReference;
//field.Pos = new PointF(k_comp.Position.X + k_symbol.fReference.Text.Pos.X, k_comp.Position.Y + k_symbol.fReference.Text.Pos.Y);
break;
case "VALUE":
sym_field = k_symbol.fValue;
field = k_comp.fValue;
//field.Pos = new PointF(k_comp.Position.X + k_symbol.fValue.Text.Pos.X, k_comp.Position.Y + k_symbol.fValue.Text.Pos.Y);
break;
//Part?
// voltage, current
}
if (field != null)
{
field.Size = (int)Common.StrToInch(attrib.Size);
SetFieldAttributes(field, StrToPointInchFlip(attrib.X, attrib.Y),
//sym_field.Text.xAngle, sym_field.Text.xMirror, k_comp.Position, attr_angle, attr_mirror);
instance_angle, k_comp.Mirror, k_comp.Position, attr_angle, attr_mirror);
//PointF p = Common.StrToPointInchFlip (attrib.X, attrib.Y);
//field.Pos = Common.StrToPointInchFlip(attrib.X, attrib.Y);
//debug
// field pos rotated about comp pos
PointF p = PointFExt.Rotate(field.Pos, k_comp.Position, k_comp.Rotation);
k.Schema.sch_wire k_line;
//// field pos +
////PointF p = field.Pos;
//k_line = sch_wire.CreateLine(new PointF(p.X - 25, p.Y), new PointF(p.X + 25, p.Y));
//k_sheet.Items.Add(k_line);
//k_line = sch_wire.CreateLine(new PointF(p.X, p.Y - 25), new PointF(p.X, p.Y + 25));
//k_sheet.Items.Add(k_line);
// actual coord of attribute |__
//p = Common.StrToPointInchFlip(attrib.X, attrib.Y);
//k_line = sch_wire.CreateLine(new PointF(p.X-50, p.Y), new PointF(p.X + 50, p.Y));
//k_sheet.Items.Add(k_line);
//k_line = sch_wire.CreateLine(new PointF(p.X, p.Y-50), new PointF(p.X, p.Y + 50));
//k_sheet.Items.Add(k_line);
}
}
//
AllComponents.Add(k_comp);
k_sheet.Components.Add(k_comp);
}
#endregion
#region ==== Busses ====
foreach (Bus bus in source_sheet.Busses.Bus)
{
foreach (Segment segment in bus.Segment)
{
foreach (Wire wire in segment.Wire)
{
k.Schema.sch_wire k_bus = sch_wire.CreateBus(StrToPointInchFlip(wire.X1, wire.Y1),
StrToPointInchFlip(wire.X2, wire.Y2));
k_sheet.Items.Add(k_bus);
BusLines.Add(new LineSegment(Vector2Ext.ToVector2(k_bus.start), Vector2Ext.ToVector2(k_bus.end)));
}
}
}
#endregion
#region ==== (Net) look for wires, junctions, labels ====
foreach (Net net in source_sheet.Nets.Net)
{
foreach (Segment segment in net.Segment)
{
List <Vector2> snap_points = new List <Vector2>();
List <LineSegment> snap_lines = new List <LineSegment>();
foreach (Wire wire in segment.Wire)
{
PointF start = StrToPointInchFlip(wire.X1, wire.Y1);
PointF end = StrToPointInchFlip(wire.X2, wire.Y2);
Vector2 p1 = Vector2Ext.ToVector2(start);
Vector2 p2 = Vector2Ext.ToVector2(end);
bool is_bus_entry = false;
foreach (LineSegment line in BusLines)
{
if (line.Contains(p1) || line.Contains(p2))
{
is_bus_entry = true;
}
}
if (is_bus_entry)
{
sch_wire k_wire = sch_wire.CreateWireToBusEntry(start, end);
k_sheet.Items.Add(k_wire);
}
else
{
sch_wire k_wire = sch_wire.CreateWire(start, end);
k_sheet.Items.Add(k_wire);
//snap_points.Add(Vector2Ext.ToVector2(k_wire.start));
//snap_points.Add(Vector2Ext.ToVector2(k_wire.end));
snap_lines.Add(new LineSegment(Vector2Ext.ToVector2(k_wire.start), Vector2Ext.ToVector2(k_wire.end)));
}
}
foreach (Junction junction in segment.Junction)
{
sch_Junction k_junction = new sch_Junction(StrToPointInchFlip(junction.X, junction.Y));
k_sheet.Items.Add(k_junction);
snap_points.Add(Vector2Ext.ToVector2(k_junction.Pos));
}
//todo: add gate positions to snap_points
foreach (Pinref pinref in segment.Pinref)
{
Part part = FindPart(pinref.Part);
k.Symbol.Symbol k_symbol = FindSymbol(part.Deviceset);
// get comp ...
PinConnection connect = connections.Find(x => x.Part == part && x.GateId == pinref.Gate && x.PinName == pinref.Pin);
if (connect == null)
{
connect = new PinConnection(net.Name, part, pinref.Gate, pinref.Pin);
connections.Add(connect);
}
}
foreach (Label label in segment.Label)
{
ExtRotation rot = ExtRotation.Parse(label.Rot);
int angle = (int)rot.Rotation;
if (rot.Mirror)
{
if ((angle % 180) == 0)
{
angle = 180 - angle;
}
}
//angle %= 360;
sch_text k_text = sch_text.CreateLocalLabel(net.Name,
StrToPointInchFlip(label.X, label.Y),
Common.StrToInch(label.Size),
angle);
// find nearest point
//k_text.Pos = FindSnapPoint(snap_points, k_text.Pos);
k_text.Pos = FindNearestPoint(snap_points, snap_lines, Vector2Ext.ToVector2(StrToPointInchFlip(label.X, label.Y)));
k_sheet.Items.Add(k_text);
AllLabels.Add(new PinConnection(k_text, k_sheet));
}
}
}
#endregion
#region add no-connects
if (option_add_no_connects)
{
foreach (Instance instance in source_sheet.Instances.Instance)
{
// find part ->
Part part = FindPart(instance.Part);
if (part == null)
{
//Trace("Part not found: " + instance.Part);
continue;
}
if (part.Library == "frames")
{
continue;
}
k.Symbol.Symbol k_symbol = FindSymbol(part.Deviceset);
//
List <PinConnection> pins = connections.FindAll(x => x.Part.Name == instance.Part && x.GateId == instance.Gate);
foreach (PinConnection p in pins)
{
// Trace(string.Format("Part {0,-10} Gate {1,-10} Pin {2,-10} Net {3,-10}", p.Part.Name, p.GateId, p.PinName, p.NetLabel));
}
//
List <PinConnection> NoConnects = new List <PinConnection>();
Symbol symbol = FindSymbol(part, instance.Gate);
foreach (Pin pin in symbol.Pin)
{
PinConnection conn = connections.Find(x => x.Part == part && x.GateId == instance.Gate && x.PinName == pin.Name);
if (conn == null)
{
//Trace(string.Format("Part {0,-10} Gate {1,-10} Pin {2,-10}", part.Name, instance.Gate, pin.Name));
NoConnects.Add(new PinConnection(null, part, instance.Gate, pin.Name));
// todo: add no-connects
PointF instance_pos = StrToPointInchFlip(instance.X, instance.Y);
PointF pin_pos = Common.StrToPointInch(pin.X, pin.Y);
ExtRotation rot = ExtRotation.Parse(instance.Rot);
pin_pos = PointFExt.Rotate(pin_pos, (int)rot.Rotation);
if (rot.Mirror)
{
pin_pos = new PointF(-pin_pos.X, pin_pos.Y);
}
PointF pos = new PointF(instance_pos.X + pin_pos.X, instance_pos.Y - pin_pos.Y);
sch_NoConnect k_noconn = new sch_NoConnect(pos);
k_sheet.Items.Add(k_noconn);
}
}
}
}
#endregion
}