Camlib¶
- class camlib.Geometry¶
- bounds()¶
Returns coordinates of rectangular bounds of geometry: (xmin, ymin, xmax, ymax).
- clear_polygon(polygon, tooldia, overlap=0.15)¶
Creates geometry inside a polygon for a tool to cover the whole area.
- convert_units(units)¶
Converts the units of the object to units by scaling all the geometry appropriately. This call scale(). Don’t call it again in descendents.
Parameters: units (str) – “IN” or “MM” Returns: Scaling factor resulting from unit change. Return type: float
- from_dict(d)¶
Sets object’s attributes from a dictionary. Attributes to include are listed in self.ser_attrs. This method will look only for only and all the attributes in self.ser_attrs. They must all be present. Use only for deserializing saved objects.
Parameters: d (dict) – Dictionary of attributes to set in the object. Returns: None
- get_empty_area(boundary=None)¶
Returns the complement of self.solid_geometry within the given boundary polygon. If not specified, it defaults to the rectangular bounding box of self.solid_geometry.
- isolation_geometry(offset)¶
Creates contours around geometry at a given offset distance.
Parameters: offset (float) – Offset distance. Returns: The buffered geometry. Return type: Shapely.MultiPolygon or Shapely.Polygon
- offset(vect)¶
Offset the geometry by the given vector. Override this method.
Parameters: vect (tuple) – (x, y) vector by which to offset the object. Returns: None
- scale(factor)¶
Scales all of the object’s geometry by a given factor. Override this method. :param factor: Number by which to scale. :type factor: float :return: None :rtype: None
- size()¶
Returns (width, height) of rectangular bounds of geometry.
- to_dict()¶
Returns a respresentation of the object as a dictionary. Attributes to include are listed in self.ser_attrs.
Returns: A dictionary-encoded copy of the object. Return type: dict
- class camlib.Gerber(Geometry)¶
ATTRIBUTES
- apertures (dict): The keys are names/identifiers of each aperture. The values are dictionaries key/value pairs which describe the aperture. The type key is always present and the rest depend on the key:
Key Value type (str) “C”, “R”, or “O” others Depend on type - paths (list): A path is described by a line an aperture that follows that line. Each paths[i] is a dictionary:
Key Value linestring (Shapely.LineString) The actual path. aperture (str) The key for an aperture in apertures. - flashes (list): Flashes are single-point strokes of an aperture. Each is a dictionary:
Key Value loc (list) [x (float), y (float)] coordinates. aperture (str) The key for an aperture in apertures. - regions (list): Are surfaces defined by a polygon (Shapely.Polygon), which have an exterior and zero or more interiors. An aperture is also associated with a region. Each is a dictionary:
Key Value polygon (Shapely.Polygon) The polygon defining the region. aperture (str) The key for an aperture in apertures. - flash_geometry (list): List of (Shapely) geometric object resulting from flashes. These are generated from flashes in do_flashes().
- buffered_paths (list): List of (Shapely) polygons resulting from buffering (or thickening) the paths with the aperture. These are generated from paths in buffer_paths().
USAGE:
g = Gerber() g.parse_file(filename) g.create_geometry() do_something(s.solid_geometry)
- aperture_parse(gline)¶
Parse gerber aperture definition into dictionary of apertures. The following kinds and their attributes are supported:
- Circular (C): size (float)
- Rectangle (R): width (float), height (float)
- Obround (O): width (float), height (float).
Parameters: gline (str) – Line of Gerber code known to have an aperture definition. Returns: Identifier of the aperture. Return type: str
- buffer_paths()¶
This is part of the parsing process. “Thickens” the paths by their appertures. This will only work for circular appertures. :return: None
- create_geometry()¶
Geometry from a Gerber file is made up entirely of polygons. Every stroke (linear or circular) has an aperture which gives it thickness. Additionally, aperture strokes have non-zero area, and regions naturally do as well.
:rtype : None :return: None
- do_flashes()¶
Creates geometry for Gerber flashes (aperture on a single point).
- fix_regions()¶
Overwrites the region polygons with fixed versions if found to be invalid (according to Shapely).
- frac_digits = None¶
Number of fraction digits in Gerber numbers. Used during parsing.
- get_bounding_box(margin=0.0, rounded=False)¶
Creates and returns a rectangular polygon bounding at a distance of margin from the object’s solid_geometry. If margin > 0, the polygon can optionally have rounded corners of radius equal to margin.
Parameters: - margin (float) – Distance to enlarge the rectangular bounding box in both positive and negative, x and y axes.
- rounded (bool) – Wether or not to have rounded corners.
Returns: The bounding box.
Return type: Shapely.Polygon
- int_digits = None¶
Number of integer digits in Gerber numbers. Used during parsing.
- offset(vect)¶
Offsets the objects’ geometry on the XY plane by a given vector. These are:
- paths
- regions
- flashes
Then buffered_paths, flash_geometry and solid_geometry are re-created with self.create_geometry(). :param vect: (x, y) offset vector. :type vect: tuple :return: None
- parse_file(filename)¶
Calls Gerber.parse_lines() with array of lines read from the given file.
- parse_lines(glines)¶
Main Gerber parser. Reads Gerber and populates self.paths, self.apertures, self.flashes, self.regions and self.units.
Parameters: glines (list) – Gerber code as list of strings, each element being one line of the source file. Returns: None Return type: None
- scale(factor)¶
Scales the objects’ geometry on the XY plane by a given factor. These are:
- apertures
- paths
- regions
- flashes
Then buffered_paths, flash_geometry and solid_geometry are re-created with self.create_geometry(). :param factor: Number by which to scale. :type factor: float :rtype : None
- class camlib.Excellon¶
ATTRIBUTES
- tools (dict): The key is the tool name and the value is the size (diameter).
- drills (list): Each is a dictionary:
Key Value point (Shapely.Point) Where to drill tool (str) A key in tools - offset(vect)¶
Offsets geometry on the XY plane in the object by a given vector.
Parameters: vect (tuple) – (x, y) offset vector. Returns: None
- parse_file(filename)¶
Reads the specified file as array of lines as passes it to parse_lines().
Parameters: filename (str) – The file to be read and parsed. Returns: None
- parse_lines(elines)¶
Main Excellon parser.
Parameters: elines (list) – List of strings, each being a line of Excellon code. Returns: None
- scale(factor)¶
Scales geometry on the XY plane in the object by a given factor. Tool sizes, feedrates an Z-plane dimensions are untouched.
Parameters: factor (float) – Number by which to scale the object. Returns: None Return type: NOne
- class camlib.CNCjob(units='in', kind='generic', z_move=0.1, feedrate=3.0, z_cut=-0.002, tooldia=0.0)¶
Represents work to be done by a CNC machine.
ATTRIBUTES
- gcode_parsed (list): Each is a dictionary:
Key Value geom (Shapely.LineString) Tool path (XY plane) kind (string) “AB”, A is “T” (travel) or “C” (cut). B is “F” (fast) or “S” (slow). - gcode_parse()¶
G-Code parser (from self.gcode). Generates dictionary with single-segment LineString’s and “kind” indicating cut or travel, fast or feedrate speed.
- generate_from_excellon(exobj)¶
Generates G-code for drilling from Excellon object. self.gcode becomes a list, each element is a different job for each tool in the excellon code.
- generate_from_excellon_by_tool(exobj, tools='all')¶
Creates gcode for this object from an Excellon object for the specified tools.
Parameters: - exobj (Excellon) – Excellon object to process
- tools – Comma separated tool names
Type: tools: str
Returns: None
Return type: None
- generate_from_geometry(geometry, append=True, tooldia=None, tolerance=0)¶
Generates G-Code from a Geometry object. Stores in self.gcode.
Parameters: - geometry (Geometry) – Geometry defining the toolpath
- append (bool) – Wether to append to self.gcode or re-write it.
- tooldia (bool) – If given, sets the tooldia property but does not affect the process in any other way.
- tolerance – All points in the simplified object will be within the tolerance distance of the original geometry.
Returns: None
Return type: None
- linear2gcode(linear, tolerance=0)¶
Generates G-code to cut along the linear feature.
Parameters: - linear – The path to cut along.
- tolerance (float) – All points in the simplified object will be within the tolerance distance of the original geometry.
Type: Shapely.LinearRing or Shapely.Linear String
Returns: G-code to cut alon the linear feature.
Return type: str
- offset(vect)¶
Offsets all the geometry on the XY plane in the object by the given vector.
Parameters: vect (tuple) – (x, y) offset vector. Returns: None
- plot2(axes, tooldia=None, dpi=75, margin=0.1, color={'C': ['#5E6CFF', '#4650BD'], 'T': ['#F0E24D', '#B5AB3A']}, alpha={'C': 1.0, 'T': 0.3}, tool_tolerance=0.0005)¶
Plots the G-code job onto the given axes.
Parameters: - axes – Matplotlib axes on which to plot.
- tooldia – Tool diameter.
- dpi – Not used!
- margin – Not used!
- color – Color specification.
- alpha – Transparency specification.
- tool_tolerance – Tolerance when drawing the toolshape.
Returns: None
- polygon2gcode(polygon, tolerance=0)¶
Creates G-Code for the exterior and all interior paths of a polygon.
Parameters: - polygon (Shapely.Polygon) – A Shapely.Polygon
- tolerance (float) – All points in the simplified object will be within the tolerance distance of the original geometry.
Returns: G-code to cut along polygon.
Return type: str
- pre_parse(gtext)¶
Separates parts of the G-Code text into a list of dictionaries. Used by self.gcode_parse().
Parameters: gtext – A single string with g-code
- scale(factor)¶
Scales all the geometry on the XY plane in the object by the given factor. Tool sizes, feedrates, or Z-axis dimensions are not altered.
Parameters: factor (float) – Number by which to scale the object. Returns: None Return type: None