def main():
"""Run as a command line program."""
parser = OptionParser()
parser.add_option("-f", "--face", dest="face",
help="name of face dxf file", metavar="FACEDXF")
parser.add_option("-t", "--temple", dest="temple",
help="name of temple dxf file", metavar="TEMPLEDXF")
parser.add_option("-n", "--name", dest="name",
help="name of hinge", metavar="HINGENAME")
parser.add_option("-o", "--outfile", dest="outfile",
help="name of output file", metavar="OUTFILE")
(options, args) = parser.parse_args()
if options.face == None or options.temple == None or options.name == None or options.outfile == None:
sys.stderr.write("Insufficient arguments.")
parser.print_help()
sys.exit(0)
facedxf = dxfgrabber.readfile(options.face)
templedxf = dxfgrabber.readfile(options.temple)
spec = {'description': options.name, 'drill_dia': 1.0, 'cb_dia': 2.0, 'cb_depth': 0.5, 'pocket_depth': 1.0}
process_contour('face', facedxf, spec)
process_contour('temple', templedxf, spec)
with open(options.outfile, 'w') as outfile:
json.dump(spec, outfile)
def main():
parser = OptionParser()
parser.add_option("-n", "--name", dest="name",
help="Name of the hinge. Program will load file called <name>.json and output <name>-face.dxf and <name>-temple.dxf.", metavar = "HINGENAME")
(options, args) = parser.parse_args()
if options.name == None:
sys.stderr.write("Not enough arguments")
parser.print_help()
sys.exit(0)
name = options.name
facename = name + "-face.dxf"
templename = name + "-temple.dxf"
facedxf = dxfgrabber.readfile(facename)
templedxf = dxfgrabber.readfile(templename)
hinge = { 'description': name }
process_contour(facedxf, "face", hinge)
process_contour(templedxf, "temple", hinge)
filename = name + ".json"
with open(filename, 'w') as outfile:
json.dump(hinge, outfile)
def refreshDXF(self):
filename = self.ui.lineEditInput.text()
self.dxf = None
self.dxf = dxfgrabber.readfile(str(filename))
try:
self.dxf = dxfgrabber.readfile(str(filename))
except Exception:
QMessageBox.critical(self, "File error", "File not found!")
self.ui.lineEditDXF.selectAll()
self.ui.lineEditDXF.setFocus()
return
self.layers = ()
for layer in self.dxf.layers:
self.layers = self.layers + (layer.name,)
sorted_layers = sorted(self.layers)
rows = self.ui.tableWidget.rowCount()
if rows > 0:
for row in range(rows):
combobox = self.ui.tableWidget.cellWidget(row, 0)
temp = u"{0}".format(combobox.itemText(combobox.currentIndex()))
combobox.clear()
combobox.setInsertPolicy(6)
combobox.addItems(sorted_layers)
if temp in sorted_layers:
combobox.setCurrentIndex(sorted_layers.index(temp))
else:
combobox.setCurrentIndex(combobox.findText("0"))
self.ui.tableWidget.setCellWidget(rows, 0, combobox)
def stress_test():
overall_time = 0
ok = 0
error = 0
print('Cython acceleration is removed since version 0.8.0')
print("Stress test:")
for filename in all_files:
try:
start_time = time.time()
dwg = dxfgrabber.readfile(filename)
end_time = time.time()
run_time = end_time - start_time
except Exception:
error += 1
print('errors at opening: {}'.format(filename))
else:
ok += 1
overall_time += run_time
print('ok ({:.2f} seconds for opening: {})'.format(
run_time, filename))
print("{:.2f} seconds for {} files".format(overall_time, ok))
print("{} errors".format(error))
print('success' if error == 0 else 'failed')
def build_roots(self):
reader = sab.SABReader()
dxf = dxfgrabber.readfile(self._dxf_path)
# read header info
self._CAD_SCALE = 1. / dxf.header.get('$DIMALTF', 1.)
# convert binary acis data to something logical
acs_ents = [
reader.read_single(x.acis) for x in dxf.entities
if isinstance(x, Body)
]
# get the translation to a logical 0
self._CAD_TRANSLATE = -1 * self.as_line_xf(
acs_ents[0], scale=self._CAD_SCALE).points[0].numpy
# read families
self.setup_point_based(
filter(lambda x: isinstance(x, Insert), dxf.entities))
pipes_long = list(
filter(
self._length_filter,
map(self.as_linecyl,
filter(self._is_valid, map(sab.SACCylinder, acs_ents)))))
pairs, tree, pts_ind = sks.connect_by_pairs(pipes_long,
factor=self.CONNECT_TOL)
node_dict = sks.make_node_dict(pairs, pts_ind, pipes_long)
root_nodes = sks.connected_components(list(node_dict.values()),
min_size=2)
final_roots = sks.kdconnect(root_nodes, tol=self._kd_tol)
return final_roots
def _read_dxf(self, filename):
"""
Read the dxf file with the dxf grabber.
Arguments:
- filename: representing the path and the name of the dxf file.
Returns: None.
Raise: PermissionError, IsADirectoryError, FileNotFoundError or generic
Exception in case of reading failure.
Try to read the dxf file with the grabber.
"""
try:
self._grabber = dxfgrabber.readfile(filename)
except PermissionError:
Logger.error("Permission error: cannot read file " + filename)
raise
except IsADirectoryError:
Logger.error("File is a directory error: cannot read file " + filename)
raise
except FileNotFoundError:
Logger.error("File not found error: cannot read file " + filename)
raise
except Exception as e:
Logger.error("Unknown exception on DXF file reading: " + str(e))
raise
def __init__(self,
filename,
interpolate_curve=50,
layers=None,
ignore=None):
"""
Reads a .dxf file
Parameters
----------
filename : str
Path to .dxf file.
interpolate_curve : int, optional (default: 50)
Number of points to use to interpolate a curve.
layers : list or dict, optional (default: all layers)
Layers to handle.
ignore : list, optional (default: None)
Names of entity types to ignore.
"""
if ignore is None:
ignore = []
self.dxf = dxfgrabber.readfile(filename)
self.interp = interpolate_curve
self.layers = layers
self.ignore = ignore
def traverse_dxf(filepath, applications=None):
"""
:param filepath:
:param applications:
:type applications: list[ActionApplication]
:return:
"""
if applications is None:
applications = []
dxf = dxfgrabber.readfile(filepath)
for e in dxf.entities.get_entities(): # type: DXFEntity
for application in applications:
if all(map(lambda x: x(e), application.rules)):
application.action(e)
if e.dxftype == "LINE":
print("LINE")
elif e.dxftype == "CIRCLE":
print("CIRCLE")
elif e.dxftype == "ARC":
print("ARC")
elif e.dxftype == "LWPOLYLINE":
print("LWPOLYLINE")
print(f"{e.layer}")
def _read_dxf(self, filename):
"""
Read the dxf file with the dxf grabber.
Arguments:
- filename: representing the path and the name of the dxf file.
Returns: None.
Raise: PermissionError, IsADirectoryError, FileNotFoundError or generic
Exception in case of reading failure.
Try to read the dxf file with the grabber.
"""
try:
self._grabber = dxfgrabber.readfile(filename)
except PermissionError:
Logger.error("Permission error: cannot read file " + filename)
raise
except IsADirectoryError:
Logger.error("File is a directory error: cannot read file " +
filename)
raise
except FileNotFoundError:
Logger.error("File not found error: cannot read file " + filename)
raise
except Exception as e:
Logger.error("Unknown exception on DXF file reading: " + str(e))
raise
def read_painting(filename):
dxf = dxfgrabber.readfile(filename)
polylines = [poly for poly in dxf.entities if type(poly) is dxfgrabber.dxfentities.LWPolyline]
painting_info = {}
for line in polylines:
sid_marker, stroke_id, cid_marker, color_id = line.layer.split("_")
if sid_marker != "STROKEID" or cid_marker != "COLORID":
print("found polyline on invalid layer")
raise InvalidPaintingFileError()
try:
stroke_id = int(stroke_id)
color_id = int(color_id)
except ValueError:
print("polyline layer '{}' stroke or color ID invalid!".format(line.layer))
raise InvalidPaintingFileError()
if stroke_id in painting_info:
if painting_info[stroke_id]['color'] != color_id:
print("found multiple layers with same stroke id but different color id!")
raise InvalidPaintingError()
painting_info[stroke_id]['lines'].append(line)
else:
painting_info[stroke_id] = {'lines': [line],
'color': color_id}
return [painting_info[i] for i in sorted(list(painting_info))]
def LoadDXF(self):
# Loads the dxf-file selected in the DXFInputBox, checks all entities in the file and appends those with the
# dxftype 'POLYLINE' (a set of points interpolated by lines) to a list. The points of the first polyline are
# then loaded into the instruction list. NOTE: ALL POINTS WITH Z-COORDINATES LESS THAN 0,5m WILL HAVE THEIR
# Z-COORDINATE SET TO 0,5 WHEN LOADED!
dxf = dxfgrabber.readfile(self.pwd +
'/src/kampala/gui/src/gui/DXFFiles/' +
self._widget.DXFInputBox.currentText())
allpolylines = [
entity for entity in dxf.entities.__iter__()
if entity.dxftype == 'POLYLINE'
]
if allpolylines != []:
linepoints = allpolylines[0].points
self._widget.Pointlist.clear()
self.pointlist = []
for point in linepoints:
if point[2] < 0.5:
safepoint = [round(point[0], 3), round(point[1], 3), 0.5]
else:
safepoint = [
round(point[0], 3),
round(point[1], 3),
round(point[2])
]
self.pointlist.append(['go to: ', safepoint])
self._widget.Pointlist.insertItem(
len(self.pointlist), 'go to: ' + str(safepoint[0]) + ',' +
str(safepoint[1]) + ',' + str(safepoint[2]))
else:
rospy.logwarn("no points in the selected DXFFile")
def read_dxf(self, filename, options=None, **kwargs):
"""reads a .dxf file
:param filename: string path to .dxf file to read
:param options: passed to :class:`~dxfgrabber.drawing.Drawing`constructor
:param kwargs: dict of optional parameters passed to :method:`Group.from_dxf`
"""
try:
import dxfgrabber
self.dxf = dxfgrabber.readfile(filename, options)
except ImportError:
logging.error('optional module dxfgrabber required')
return
except Exception as e:
logging.error('could not read %s : %s' % (filename, e))
return
self.name = filename
#build dictionary of blocks
self.block = {}
for block in self.dxf.blocks:
self.block[block.name] = Group().from_dxf(block._entities,
**kwargs)
super(Drawing, self).from_dxf(self.dxf.entities, **kwargs)
return self
def main():
if (len(sys.argv) != 4):
print("use with params <input file> <output file> <height room>")
return
dxf = dxfgrabber.readfile(sys.argv[1])
height_room = float(sys.argv[3])
lines = [entity for entity in dxf.entities if entity.dxftype == 'LINE']
polylines = [
entity for entity in dxf.entities if entity.dxftype == 'LWPOLYLINE'
]
vertexes = ''
faces = ''
index = 0
result = convertLines(lines, vertexes, faces, index, height_room)
vertexes = result[0]
faces = result[1]
index = result[2]
result = convertPolylines(polylines, vertexes, faces, index, height_room)
vertexes = result[0]
faces = result[1]
index = result[2]
file = open(sys.argv[2], 'w+')
file.write(vertexes)
file.write(faces)
file.close()
def read_dxf(self, filename, options=None, **kwargs):
"""reads a .dxf file
:param filename: string path to .dxf file to read
:param options: passed to :class:`~dxfgrabber.drawing.Drawing`constructor
"""
import dxfgrabber
self.dxf = dxfgrabber.readfile(filename,options)
self.name = filename
def _iter_dxf(entities, layers, only, ignore, trans, recurse):
"""iterator over dxf or block entities"""
for e in entities:
if layers and e.layer not in layers:
continue
if only:
if e.dxftype in only:
yield e, trans
else:
continue
elif e.dxftype in ignore:
continue
elif recurse and e.dxftype == 'INSERT':
t2 = trans*Trans(1, e.insert[:2], e.rotation)
for e2, t3 in _iter_dxf(self.dxf.blocks[e.name]._entities, layers=None, ignore=ignore, only=None, trans=t2, recurse=recurse):
yield e2, t3
else:
yield e, trans
layers=kwargs.get('layers',None)
only=kwargs.get('only',[])
ignore=kwargs.get('only',[])
for edge,trans in _iter_dxf(self.dxf.entities,layers=layers,only=only,ignore=ignore,trans=Trans(),recurse=True):
self.append(Entity.from_dxf(edge, trans))
def __init__(self,
dxfFileName,
layerNamesToImport,
getRelativeCoo,
threshold=0.01,
importLines=True,
importSurfaces=True):
''' Constructor.
:param layerNamesToImport: list of regular expressions to be tested.
:param getRelativeCoo: coordinate transformation to be applied to the
points.
'''
self.dxfFile = dxfgrabber.readfile(dxfFileName)
self.layersToImport = self.getLayersToImport(layerNamesToImport)
self.getRelativeCoo = getRelativeCoo
self.threshold = threshold
self.selectKPoints()
self.labelDict = {}
self.points = self.importPoints()
if (importLines):
self.importLines()
else:
self.lines = {}
if (importSurfaces):
self.importFaces()
else:
self.facesByLayer = {}
def __init__(self,dxfFileName,layerNamesToImport, getRelativeCoo, threshold= 0.01,importLines= True, importSurfaces= True, polylinesAsSurfaces= False, tolerance= .01):
''' Constructor.
:param layerNamesToImport: list of regular expressions to be tested.
:param getRelativeCoo: coordinate transformation to be applied to the
points.
'''
self.options= {"grab_blocks":True,"assure_3d_coords":True,"resolve_text_styles":True}
self.dxfFile= dxfgrabber.readfile(filename= dxfFileName, options= self.options)
self.tolerance= tolerance
self.impLines= importLines
self.impSurfaces= importSurfaces
self.polylinesAsSurfaces= polylinesAsSurfaces
self.layersToImport= self.getLayersToImport(layerNamesToImport)
self.polyfaceQuads= dict()
self.polylineQuads= dict()
self.getRelativeCoo= getRelativeCoo
self.threshold= threshold
self.labelDict= {}
self.kPointsNames= self.selectKPoints()
self.importPoints()
if(self.impLines):
self.importLines()
else:
self.lines= {}
if(self.impSurfaces):
self.importFaces()
else:
self.facesByLayer= {}
def read_dxf(self):
t1 = sec()
print(out(outpth, 'Reading DXF geometry...'), end='\r')
dxffile = dxf.readfile('{}.dxf'.format(self.title))
print(out(outpth, '[OK] DXF geometry imported ({} s)'.format(round(sec() - t1, 2))))
beams = []
columns = []
x = 0
t = len(dxffile.entities)
# assign LINES elements to columns or beams tables
for ent in dxffile.entities:
progressBar('Converting lines', x, t)
if ent.dxftype == 'LINE':
if ent.start[2] == ent.end[2]:
beams.append(ent)
else:
columns.append(ent)
x += 1
print(out(outpth, '[OK] Lines converted '))
# assign 3DFACE elements to shells table
shells = [ent for ent in dxffile.entities if ent.dxftype == '3DFACE']
return {'b': beams, 'c': columns, 's': shells, 'f': []}
def __init__(self,param):
self.param = dict(self.DEFAULT_PARAM)
self.param.update(param)
try:
self.dwg = self.param['dwg']
except KeyError:
self.dwg = dxfgrabber.readfile(self.param['fileName'])
self.makeListOfCmds()
def saveLinesByTypes(filepath):
#read cad files
dxf = dxfgrabber.readfile(filepath)
lines = []
wall_kw = ['WALL','wall']
glass_kw = ['窗','WINDOWS','玻璃']
wood_kw = ['门扇']
other_kw = ['阴影','垂直面']
all_kw = wall_kw+glass_kw+wood_kw+other_kw
#layerkeywordlist = ['窗','WALL','wall','WINDOWS','玻璃','垂直面','门扇','阴影']
for e in dxf.entities:
for kw in all_kw:
if kw not in e.layer:
continue
#linestype = -1
#reduce_dist = 0
#print(linestype)
if kw in wall_kw:
linestype = 0
#reduce_dist = wall_reduce_dist
elif kw in glass_kw:
linestype = 1
#reduce_dist = glass_reduce_dist
elif kw in wood_kw:
linestype = 2
#reduce_dist = wood_reduce_dist
else:
linestype = 3
#reduce_dist = other_reduce_dist
if e.dxftype == 'LINE':
if e.start[0] < 150000:
continue
x1 = round(e.start[0])
y1 = round(e.start[1])
x2 = round(e.end[0])
y2 = round(e.end[1])
lines.append([x1, y1, x2, y2, linestype])
elif e.dxftype == 'LWPOLYLINE':
p = e.points
for i in range(len(p) - 1):
if p[i][0] < 150000:
continue
lines.append([round(p[i][0]), round(p[i][1]), round(p[i + 1][0]), round(p[i + 1][1]), linestype])
if e.is_closed:
if p[0][1] < 0 or p[0][0] < 150000:
continue
lines.append([round(p[0][0]), round(p[0][1]), round(p[-1][0]), round(p[-1][1]), linestype])
break
nums = len(lines)
print(nums)
df = pd.DataFrame(lines)
print(df)
save_path = os.getcwd().replace("\\",'/')+"/data/linesDataByMaterials.csv"
df.to_csv(save_path, index=0, sep=',', header=None)
print('success')
def main():
"""Run as a command line program."""
parser = OptionParser()
parser.add_option("-f",
"--face",
dest="face",
help="name of face dxf file",
metavar="FACEDXF")
parser.add_option("-t",
"--temple",
dest="temple",
help="name of temple dxf file",
metavar="TEMPLEDXF")
parser.add_option("-n",
"--name",
dest="name",
help="name of hinge",
metavar="HINGENAME")
parser.add_option("-o",
"--outfile",
dest="outfile",
help="name of output file",
metavar="OUTFILE")
(options, args) = parser.parse_args()
if options.face == None or options.temple == None or options.name == None or options.outfile == None:
sys.stderr.write("Insufficient arguments.")
parser.print_help()
sys.exit(0)
facedxf = dxfgrabber.readfile(options.face)
templedxf = dxfgrabber.readfile(options.temple)
spec = {
'description': options.name,
'drill_dia': 1.0,
'cb_dia': 2.0,
'cb_depth': 0.5,
'pocket_depth': 1.0
}
process_contour('face', facedxf, spec)
process_contour('temple', templedxf, spec)
with open(options.outfile, 'w') as outfile:
json.dump(spec, outfile)
def main(filename):
print('lng,lat,blockname')
dxf = dxfgrabber.readfile(filename)
for entity in dxf.entities:
if entity.dxftype == 'INSERT':
coords = pyproj.transform(epsg3945, wgs84, entity.insert[0],
entity.insert[1])
print(repr(coords[0]) + ',' + repr(coords[1]) + ',' + entity.name)
def __init__(self, file, layers=None, ignore=[]):
"""reads a .dxf file
:param file: string path to .dxf file to read
:param layers: list or dictionary of layers to handle. Empty = all layers
:param ignore: list of strings of entity types to ignore
"""
self.dxf=dxfgrabber.readfile(file)
self.layers=layers
self.ignore=ignore
def main(filename):
print("reading file: {}".format(filename))
starttime = time.time()
dxf = dxfgrabber.readfile(filename)
endtime = time.time()
print("time to read: {:.2f}s".format(endtime - starttime))
print("entities: {:d}".format(len(dxf.entities)))
print("defined Layers: {}".format(len(dxf.layers)))
print_layers(Counter(entity.layer for entity in dxf.entities))
def main():
app = DXFApplication(sys.argv)
drawing = dxfgrabber.readfile(sys.argv[1])
w = DXFMainWindow(drawing)
w.show()
retcode = app.exec_()
w = None
app = None
return retcode
def __init__(self, param):
self.param = dict(self.DEFAULT_PARAM)
self.param['laserDIOPin'] = self.LASER_DIO_PIN
self.param['laserHomeXY'] = self.LASER_HOME_XY
self.param.update(param)
try:
self.dwg = self.param['dwg']
except KeyError:
self.dwg = dxfgrabber.readfile(self.param['fileName'])
self.makeListOfCmds()
def read_dxf(filename):
dxf = dxfgrabber.readfile(filename)
polylines = [poly for poly in dxf.entities if type(poly) is dxfgrabber.dxfentities.LWPolyline]
paths = []
for line in polylines:
path = []
for pt in line:
path += [(pt[0]/1000.0, pt[1]/1000.0)]
paths += [path]
return paths
def read(self,dxf_file_name,xc_preprocessor,layers):
self.dxf= dxfgrabber.readfile(dxf_file_name)
self.preprocessor= xc_preprocessor
self.pointHandler= self.preprocessor.getMultiBlockTopology.getPoints
self.lineHandler= self.preprocessor.getMultiBlockTopology.getLines
self.pointsInLayer= {}
self.blocksInLayer= {}
for l in layers:
self.pointsInLayer[l]= self.read_points(self.dxf.entities,l)
self.blocksInLayer[l]= self.read_lines(self.dxf.entities,l)
def read(self,dxf_file_name,xc_preprocessor,layers):
self.dxf= dxfgrabber.readfile(dxf_file_name)
self.preprocessor= xc_preprocessor
self.pointHandler= self.preprocessor.getMultiBlockTopology.getPoints
self.lineHandler= self.preprocessor.getMultiBlockTopology.getLines
self.pointsInLayer= {}
self.blocksInLayer= {}
for l in layers:
self.pointsInLayer[l]= self.read_points(self.dxf.entities,l)
self.blocksInLayer[l]= self.read_lines(self.dxf.entities,l)
def test_open_proe_ac1018(self):
dwg = dxfgrabber.readfile("D:\Source\dxftest\ProE_AC1018.dxf")
modelspace = list(dwg.modelspace())
# are there entities in model space
self.assertEqual(17, len(modelspace))
# can you get entities
lines = [entity for entity in modelspace if entity.dxftype == 'LINE']
self.assertEqual(12, len(lines))
def __init__(self, dxf_path):
self.dxf_path = dxf_path #'../客流点位图-F.dxf'
dxf = dxfgrabber.readfile(self.dxf_path)
ids = [e for e in dxf.entities if e.layer == 'ID' and (e.dxftype == 'TEXT' or e.dxftype == 'MTEXT')]
bounds = [e for e in dxf.entities if e.layer == 'Bounds' and e.dxftype == 'LWPOLYLINE']
self.bounds = np.array([e.points for e in bounds])
self.ids_center = np.array([self.get_mtext_center(e,dxf.styles.get(e.style).width) if e.dxftype == 'MTEXT' else self.get_text_center(e) for e in ids])
self.bounds_center = np.array([self.get_centerpoint(bound) for bound in bounds])
self.ids_text = [self.get_text(e) for e in ids]
def read(self):
self.dxf = dxfgrabber.readfile(self.file)
self.objects = [
entity for entity in self.dxf.entities
if entity.layer == self.layer
] #and entity.dxftype=='LINE' or entity.dxftype=='LINE' ]
self.objects = [
entity for entity in self.objects
if entity.dxftype == 'LINE' or entity.dxftype == 'POLYLINE'
]
#x=np.array[entity.points]
self.x = np.array([])
self.y = np.array([])
self.przerwyX = []
for i, entity in enumerate(self.objects):
if entity.dxftype == "POLYLINE":
x = np.array(
[entity.points[i][0] for i in range(len(entity.points))])
y = np.array(
[entity.points[i][1] for i in range(len(entity.points))])
elif entity.dxftype == "LINE":
#assert entity.start[0]<entity.end[0], "Jakas linia ma odwrocona kolejnosc start-end"
x = np.array([entity.start[0], entity.end[0]])
y = np.array([entity.start[1], entity.end[1]])
if i == 0:
pass
else:
if abs(x.min() - self.x.max()) < 10:
pass #Jest zachowana ciaglosc
else:
self.przerwyX.append([self.x.max(), x.min()])
self.x = np.append(self.x, x)
self.y = np.append(self.y, y)
self.xy = np.column_stack((self.x, self.y))
self.xy = sorted(self.xy, key=lambda k: [k[0], k[1]])
self.xymin = self.xy[0]
self.x = self.x - self.xymin[0] + self.startKm
self.x = self.x / self.xScale
self.y = self.y - self.xymin[1]
self.y = self.y / self.yScale + self.startLevel
self.przerwyX = (np.array(self.przerwyX) - self.xymin[0] +
self.startKm) / self.xScale
self.interline = interpolate.interp1d(self.x, self.y, kind="linear")
def Open(self):
name = askopenfilename(
initialdir=
"D:/Users/BENDJOUDI/Documents/Documents/GithubMaster/Interface/",
filetypes=(("CSV File", "*.dxf"), ("All Files", "*.*")),
title="Choose a file.")
import dxfgrabber
dwg = dxfgrabber.readfile(name)
print("DXF version:{} ".format(dwg.dxfversion))
layer_names = dwg.layers.names()
all_layers = {}
entitie = [entity for entity in dwg.entities]
for n in layer_names:
all_layers.update({str(n) : [entity for entity in dwg.entities if (entity.layer == str(n)) and (entity.dxftype == 'LWPOLYLINE' or entity.dxftype == 'SOLID') \
and entity.layer != 'CARTOUCHE' and entity.layer != 'S_ZONE___E' and entity.layer != 'LEGENDE' and entity.layer != 'C_PLA_KR_T']})
layers_list = {
i: all_layers[i]
for i in all_layers if all_layers[i] != []
}
for key in layers_list:
color = []
for e in layers_list[key]:
color.append(e.color)
self.NewPlan()
l = {}
for key in layers_list:
f = []
for e in layers_list[key]:
k = []
for i in e.points:
k.append((i[0] / 300, -i[1] / 300))
f.append(k)
l.update({key: f})
i = 0
for key in l:
i += 1
for e in range(len(l[key])):
self.canvas.create_polygon(
l[key][e],
outline=self.color[i]["hexString"],
fill=self.color[i]["hexString"],
tags=[str(self.color[i]['colorId']),
str(key)])
print('i = ', i)
return name
def __init__(self,dxf_path):
print('***dxfProcessor inited:')
self.dxf = dxfgrabber.readfile(dxf_path)
self.dxf_path = dxf_path
self.entities = [e for e in self.dxf.entities if (e.layer != 'ID' and e.layer !='Bounds')]
self.line = self.get_line(self.entities)
self.arc = self.get_arc(self.entities)
self.ellipse = self.get_ellipse(self.entities)
self.lwpline = self.get_lwpline(self.entities)
self.xa, self.xi, self.ya, self.yi = self.set_boundary(self.line)
print('***dxfProcessor finished:')
def __init__(self, dxfpath, dico_dxf, tipo, txt=''):
u""" Uses OGR functions to extract basic informations about
geographic vector file (handles shapefile or MapInfo tables)
and store into dictionaries.
dxfpath = path to the File Geodatabase Esri
dico_dxf = dictionary for global informations
dico_fields = dictionary for the fields' informations
li_fieds = ordered list of fields
tipo = format
text = dictionary of text in the selected language
"""
# opening
dxf = dxfgrabber.readfile(dxfpath)
# AutoCAD version
dico_dxf['version_code'] = dxf.dxfversion
# see: http://dxfgrabber.readthedocs.org/en/latest/#Drawing.dxfversion
if dxf.dxfversion == 'AC1009':
dico_dxf['version_name'] = 'AutoCAD R12'
elif dxf.dxfversion == 'AC1015':
dico_dxf['version_name'] = 'AutoCAD R2000'
elif dxf.dxfversion == 'AC1018':
dico_dxf['version_name'] = 'AutoCAD R2004'
elif dxf.dxfversion == 'AC1021':
dico_dxf['version_name'] = 'AutoCAD R2007'
elif dxf.dxfversion == 'AC1024':
dico_dxf['version_name'] = 'AutoCAD R2010'
elif dxf.dxfversion == 'AC1027':
dico_dxf['version_name'] = 'AutoCAD R2013'
else:
dico_dxf['version_name'] = 'NR'
# headers
dico_dxf['headers_var_count'] = len(dxf.header)
# layers count
dico_dxf['layers_count'] = len(dxf.layers)
# entities count
dico_dxf['entities_count'] = len(dxf.entities)
# blocs count
dico_dxf['blocks_count'] = len(dxf.blocks)
# encoding
dico_dxf['encoding'] = dxf.encoding
# entities
dico_dxf['entities'] = [
entity for entity in dxf.entities if entity.layer == '1'
]
def print_all_entity_reprs(filename, output):
dxf = dxfgrabber.readfile(filename)
all_entities = [entity for entity in dxf.entities]
for block in dxf.blocks:
for entity in block:
all_entities.append(entity)
for e in all_entities:
if sys.version_info[0] == 2:
value = str(e).decode('utf-8') + "\t" + repr(e).decode('utf-8')
else:
value = str(e) + "\t" + repr(e)
output.write(value.encode('utf-8'))
output.write(os.linesep.encode())
def __init__(self, dxfpath, dico_dxf, tipo, txt=''):
u""" Uses OGR functions to extract basic informations about
geographic vector file (handles shapefile or MapInfo tables)
and store into dictionaries.
dxfpath = path to the File Geodatabase Esri
dico_dxf = dictionary for global informations
dico_fields = dictionary for the fields' informations
li_fieds = ordered list of fields
tipo = format
text = dictionary of text in the selected language
"""
# opening
dxf = dxfgrabber.readfile(dxfpath)
# AutoCAD version
dico_dxf['version_code'] = dxf.dxfversion
# see: http://dxfgrabber.readthedocs.org/en/latest/#Drawing.dxfversion
if dxf.dxfversion == 'AC1009':
dico_dxf['version_name'] = 'AutoCAD R12'
elif dxf.dxfversion == 'AC1015':
dico_dxf['version_name'] = 'AutoCAD R2000'
elif dxf.dxfversion == 'AC1018':
dico_dxf['version_name'] = 'AutoCAD R2004'
elif dxf.dxfversion == 'AC1021':
dico_dxf['version_name'] = 'AutoCAD R2007'
elif dxf.dxfversion == 'AC1024':
dico_dxf['version_name'] = 'AutoCAD R2010'
elif dxf.dxfversion == 'AC1027':
dico_dxf['version_name'] = 'AutoCAD R2013'
else:
dico_dxf['version_name'] = 'NR'
# headers
dico_dxf['headers_var_count'] = len(dxf.header)
# layers count
dico_dxf['layers_count'] = len(dxf.layers)
# entities count
dico_dxf['entities_count'] = len(dxf.entities)
# blocs count
dico_dxf['blocks_count'] = len(dxf.blocks)
# encoding
dico_dxf['encoding'] = dxf.encoding
# entities
dico_dxf['entities'] = [entity for entity in dxf.entities if entity.layer == '1']
def libdxfgrabber(request):
now = datetime.datetime.now()
logging.basicConfig(filename='log/libdxfgrabber.log', level=logging.INFO)
logging.info( "" )
logging.info(' #------------------------------------------------# ')
logging.info( now )
logging.info(' # Begin Views Function ==> Library dxfgrabber ')
logging.info( "" )
dxfg = dxfgrabber.readfile("dxffiles/habitacion.dxf")
# dxf = dxfgrabber.readfile("dxffiles/pared.dxf");
# dxf = dxfgrabber.readfile("dxffiles/hostel.dxf")
logging.info( "" )
logging.info(' #------------------------------------------------# ')
logging.info(' # DXF information: ')
dxfg_version = dxfg.dxfversion
logging.info(' # Version [ %s ] ', dxfg_version)
dxfversiong = dxfg.header['$ACADVER']
# header_var_count = len(dxf.header) # dict of dxf header vars
# logging.info(' # Nº vars header [ %d ] ', header_var_count)
layer_count = len(dxfg.layers) # collection of layer definitions
logging.info(' # Nº vars layer [ %d ] ', layer_count)
block_definition_count = len(dxfg.blocks) # dict like collection of block definitions
logging.info(' # Nº vars count definition [ %d ] ', block_definition_count)
entity_count = len(dxfg.entities)
logging.info(' # Nº vars entities [ %d ] ', entity_count)
logging.info(' # Codificación dibujo [ %s ] ', dxfg.encoding)
namefile = dxfg.filename
logging.info(' # Nombre fichero [ %s ] ', namefile)
logging.info(' #------------------------------------------------# ')
modelspace = dxfg.modelspace()
j = 1
logging.info( "" )
logging.info(' # End Views Function ==> Library dxfgrabber ')
logging.info(' #------------------------------------------------# ')
logging.info( "" )
for e in modelspace:
# tipo = e.dxftype()
# logging.info( " tipo %s", tipo )
# logging.info(' # Layer [ %s ] ', e.dxfg.layer)
logging.info( " modelspace [ %d ]" %j)
logging.info( "" )
j = j + 1
return render_to_response('libdxfgrabber/dxfhomedxfgrab.html', locals())
def rdxf(filename):
dxf = dxfgrabber.readfile(filename)
x_max, x_min, y_max, y_min = -float('inf'), float('inf'), -float('inf'), float('inf')
for e in dxf.entities:
typename = e.dxftype
print(typename)
if typename == 'LWPOLYLINE':
# update boundary
x_max, y_max = np.max((np.max(e.points, 0), (x_max, y_max)), 0)
x_min, y_min = np.min((np.min(e.points, 0), (x_min, y_min)), 0)
elif typename == 'LINE':
# update boundary
x_max, y_max = np.max((np.max((e.start, e.end), 0), (x_max, y_max)), 0)
x_min, y_min = np.min((np.min((e.start, e.end), 0), (x_min, y_min)), 0)
elif typename == 'SPLINE':
# update boundary
cpoints = np.array(e.controlpoints)
x_max, y_max = np.max((np.max(cpoints[:, (0,1)], 0), (x_max, y_max)), 0)
x_min, y_min = np.min((np.min(cpoints[:, (0,1)], 0), (x_min, y_min)), 0)
print('n_ctrlp: %d' % len(e.controlpoints))
w = e.weights
for (i, pt) in enumerate(e.controlpoints):
print('ctrlp: %f %f %f' % (pt[0]*w[i], pt[1]*w[i], pt[2]*w[i]))
for (index, knot) in enumerate(e.knots):
print('knot: %f' % (knot))
print('u_min: %f' % e.knots[0])
print('u_max: %f' % e.knots[-1])
pass
else:
print('Not Implemented')
print('x_max: {}\ny_max: {}'.format(x_max, y_max))
print('x_min: {}\ny_min: {}'.format(x_min, y_min))
def export_zt():
p = ur'H:\work\云南接图表.dxf'
p1 = ur'H:\work\yn_tiles_index.json'
p2 = ur'H:\work\yn_tiles_index_zt.json'
dxf = dxfgrabber.readfile(p)
print("DXF version: {%s}" % str(dxf.dxfversion))
cnt = 0
l = []
#d = {}
coordlist = {}
for entity in dxf.entities:
if entity.layer=='0':
cnt += 1
d = {}
if hasattr(entity, 'points'):
#print('len(entity.points)=%d' % len(entity.points))
if len(entity.points) == 4:
coordlist['ld'] = entity.points[0]
coordlist['rd'] = entity.points[1]
coordlist['ru'] = entity.points[2]
coordlist['lu'] = entity.points[3]
if hasattr(entity, 'text'):
if len(coordlist.keys())>0:
d[entity.text] = coordlist
if len(d.keys())>0:
l.append(d)
coordlist = {}
with open(p1, 'w') as f:
f.write(json.dumps(l))
d = {}
for i in l:
key = i.keys()[0]
keyintrow = int(key[0:3])
keyintcol = int(key[3:])
if keyintrow <= 34 and keyintrow + keyintcol >= 62:
d[key] = i[key]
with open(p2, 'w') as f:
f.write(json.dumps(d))
print(len(d.keys()))
def to_polygon(filename):
"""Returns list of [x,y] points from DXF."""
dxf = dxfgrabber.readfile(filename)
points = []
for e in dxf.entities:
if isinstance(e, dxfgrabber.entities.Line):
points += line_to_points(e)
elif isinstance(e, dxfgrabber.entities.Polyline):
points += polyline_to_points(e)
elif isinstance(e, dxfgrabber.entities.Arc):
points += arc_to_points(e)
elif isinstance(e, dxfgrabber.entities.Circle):
pass
else:
raise Exception("Unrecognized DXF entity %s." % str(e))
return filter_duplicate_points(points)
def __init__(self,dxfFileName,layerNamesToImport, getRelativeCoo, threshold= 0.01,importLines= True, importSurfaces= True):
''' Constructor.
:param layerNamesToImport: list of regular expressions to be tested.
:param getRelativeCoo: coordinate transformation to be applied to the
points.
'''
self.dxfFile= dxfgrabber.readfile(dxfFileName)
self.layersToImport= self.getLayersToImport(layerNamesToImport)
self.getRelativeCoo= getRelativeCoo
self.threshold= threshold
self.selectKPoints()
self.labelDict= {}
self.points= self.importPoints()
if(importLines):
self.importLines()
else:
self.lines= {}
if(importSurfaces):
self.importFaces()
else:
self.facesByLayer= {}
def LoadDXF(self):
# Loads the dxf-file selected in the DXFInputBox, checks all entities in the file and appends those with the
# dxftype 'POLYLINE' (a set of points interpolated by lines) to a list. The points of the first polyline are
# then loaded into the instruction list. NOTE: ALL POINTS WITH Z-COORDINATES LESS THAN 0,5m WILL HAVE THEIR
# Z-COORDINATE SET TO 0,5 WHEN LOADED!
dxf = dxfgrabber.readfile(self.pwd + '/src/kampala/gui/src/gui/DXFFiles/' + self._widget.DXFInputBox.currentText())
allpolylines = [entity for entity in dxf.entities.__iter__() if entity.dxftype == 'POLYLINE']
if allpolylines != []:
linepoints = allpolylines[0].points
self._widget.Pointlist.clear()
self.pointlist = []
for point in linepoints:
if point[2] < 0.5:
safepoint = [round(point[0],3),round(point[1],3),0.5]
else:
safepoint = [round(point[0],3),round(point[1],3),round(point[2])]
self.pointlist.append(['go to: ',safepoint])
self._widget.Pointlist.insertItem(len(self.pointlist),'go to: ' + str(safepoint[0]) + ',' + str(safepoint[1]) + ',' + str(safepoint[2]))
else:
rospy.logwarn("no points in the selected DXFFile")
def showDialog():
workdir = json.loads("settings.json")
filename = Qt.QFileDialog.getOpenFileName(mainWindow, "Open_file", workdir["workdirectory"], "*.dxf")
try:
dxf = dxfgrabber.readfile(filename)
except DXFStructureError:
msgError = Qt.QErrorMessage()
msgError.showMessage("Неверная структура DXF файла! "+"Введите координаты в ручном режиме.")
all_entety = [enity for enity in dxf.entities]
all_rastr = []
name = combobox.itemText(combobox.currentIndex())
# Чтение координат из файла
for i in all_entety:
# Ищем координаты только полилиний (Такое чувство, что есть еще какой то тип)
if i.__class__ == dxfgrabber.dxfentities.Polyline or i.__class__ == dxfgrabber.dxfentities.LWPolyline:
for j in i.points:
coord_x = float(round(list(j)[0], 2))
coord_y = float(round(list(j)[1], 2))
# Добавление номера растра полученного из findrastres(почему то не всегда точно получаем номер)
all_rastr.append(findrastres(name, coord_x, coord_y))
elif i.__class__ == dxfgrabber.dxfentities.Point:
coord_x = float(round(list(i.point)[0], 2))
coord_y = float(round(list(i.point)[1], 2))
if coord_x != 1323201.82 and coord_y != 416377.63:
# Добавление номера растра полученного из findrastres(почему то не всегда точно получаем номер)
all_rastr.append(findrastres(name, coord_x, coord_y))
else:
answer.setText("Не допустимые линии на чертеже!")
# исключаем одинаковые растры
all_rastr = set(all_rastr)
all_rastr = list(all_rastr)
if len(all_rastr) == 1:
answer.setText(str(all_rastr[0]))
else:
text = str(all_rastr[0])
for i in range(1,len(all_rastr)):
text = text + ", " + all_rastr[i]
answer.setText(text)
def load(self, path):
dbgfname()
dxf = dxfgrabber.readfile(path)
debug(" DXF version: {}".format(dxf.dxfversion))
header_var_count = len(dxf.header) # dict of dxf header vars
layer_count = len(dxf.layers) # collection of layer definitions
block_definition_count = len(dxf.blocks) # dict like collection of block definitions
entity_count = len(dxf.entities) # list like collection of entities
blocks = dxf.blocks
paths = []
entities = [e for e in dxf.entities]
p = Path(Singleton.state, [], "ungrouped", Singleton.state.settings.get_def_lt().name)
for e in entities:
if self.__is_basic(e):
self.__basic_el(e, p, None, dxf.layers, None, None)
elif e.dxftype == DXFEnum.insert:
block_name = e.name
offset = e.insert[:2]
rotation = e.rotation
scale = e.scale[:2]
tp = Path(Singleton.state, [], block_name, Singleton.state.settings.get_def_lt().name)
for b in dxf.blocks:
if b.name == block_name:
for e in b:
if self.__is_basic(e):
self.__basic_el(e, tp, offset, dxf.layers, b, scale, rotation)
else:
debug(" Unknown type: "+str(e.dxftype))
debug(" "+str(e))
paths.append(tp)
else:
debug(" Unknown type: "+str(e.dxftype))
debug(" "+str(e))
if len(p.elements)>0:
paths.append(p)
return paths
def rdxf(filename):
dxf = dxfgrabber.readfile(filename)
for e in dxf.entities:
typename = e.dxftype
print(typename)
if typename == 'SPLINE':
#print(e.__dict__)
print('n_ctrlp: %d' % len(e.controlpoints))
w = e.weights
for (i, pt) in enumerate(e.controlpoints):
print('ctrlp: %f %f %f' % (pt[0]*w[i], pt[1]*w[i], pt[2]*w[i]))
for (index, knot) in enumerate(e.knots):
print('knot: %f' % (knot))
print('u_min: %f' % e.knots[0])
print('u_max: %f' % e.knots[-1])
pass
else:
print('Not Implemented')
def read_dxf(self, filename, options=None, **kwargs):
"""reads a .dxf file
:param filename: string path to .dxf file to read
:param options: passed to :class:`~dxfgrabber.drawing.Drawing`constructor
:param kwargs: dict of optional parameters passed to :method:`Group.from_dxf`
"""
try:
import dxfgrabber
self.dxf = dxfgrabber.readfile(filename,options)
except ImportError:
logging.error('optional module dxfgrabber required')
return
except Exception as e:
logging.error('could not read %s : %s'%(filename,e))
return
self.name = filename
#build dictionary of blocks
self.block={}
for block in self.dxf.blocks:
self.block[block.name]=Group().from_dxf(block._entities, **kwargs)
super(Drawing, self).from_dxf(self.dxf.entities, **kwargs)
return self
def __init__(self, dxfpath, dico_dxf, tipo, txt=''):
u""" Uses OGR functions to extract basic informations about
geographic vector file (handles shapefile or MapInfo tables)
and store into dictionaries.
dxfpath = path to the DXF file
dico_dxf = dictionary for global informations
tipo = format
text = dictionary of text in the selected language
"""
# changing working directory to layer folder
chdir(path.dirname(dxfpath))
# raising GDAL/OGR specific exceptions
ogr.UseExceptions()
self.alert = 0
# opening DXF
dr_dxf = ogr.GetDriverByName("DXF")
try:
dxf = dr_dxf.Open(dxfpath, 0)
except Exception as e:
print(e)
return
# check if DXF is OGR friendly
if dxf is None:
self.alert += 1
self.erratum(dico_dxf, dxfpath, u'err_incomp')
return
else:
pass
# DXF name and parent folder
dico_dxf['name'] = path.basename(dxf.GetName())
dico_dxf['folder'] = path.dirname(dxf.GetName())
# opening
douxef = dxfgrabber.readfile(dxfpath)
# AutoCAD version
dico_dxf['version_code'] = douxef.dxfversion
# see: http://dxfgrabber.readthedocs.org/en/latest/#Drawing.dxfversion
if douxef.dxfversion == 'AC1009':
dico_dxf['version_name'] = 'AutoCAD R12'
elif douxef.dxfversion == 'AC1015':
dico_dxf['version_name'] = 'AutoCAD R2000'
elif douxef.dxfversion == 'AC1018':
dico_dxf['version_name'] = 'AutoCAD R2004'
elif douxef.dxfversion == 'AC1021':
dico_dxf['version_name'] = 'AutoCAD R2007'
elif douxef.dxfversion == 'AC1024':
dico_dxf['version_name'] = 'AutoCAD R2010'
elif douxef.dxfversion == 'AC1027':
dico_dxf['version_name'] = 'AutoCAD R2013'
else:
dico_dxf['version_name'] = 'NR'
# layers count and names
dico_dxf['layers_count'] = dxf.GetLayerCount()
li_layers_names = []
li_layers_idx = []
dico_dxf['layers_names'] = li_layers_names
dico_dxf['layers_idx'] = li_layers_idx
# dependencies
dependencies = [f for f in listdir(path.dirname(dxfpath))
if path.splitext(path.abspath(f))[0] == path.splitext(dxfpath)[0]
and not path.splitext(path.abspath(f).lower())[1] == ".dxf"]
dico_dxf[u'dependencies'] = dependencies
# cumulated size
dependencies.append(dxfpath)
total_size = sum([path.getsize(f) for f in dependencies])
dico_dxf[u"total_size"] = self.sizeof(total_size)
dependencies.pop(-1)
# global dates
dico_dxf[u'date_actu'] = strftime('%d/%m/%Y',
localtime(path.getmtime(dxfpath)))
dico_dxf[u'date_crea'] = strftime('%d/%m/%Y',
localtime(path.getctime(dxfpath)))
# total fields count
total_fields = 0
dico_dxf['total_fields'] = total_fields
# total objects count
total_objs = 0
dico_dxf['total_objs'] = total_objs
# parsing layers
for layer_idx in range(dxf.GetLayerCount()):
# dictionary where will be stored informations
dico_layer = OD()
# parent DXF
dico_layer['dxf_name'] = path.basename(dxf.GetName())
# getting layer object
layer = dxf.GetLayerByIndex(layer_idx)
# layer name
li_layers_names.append(layer.GetName())
# layer index
li_layers_idx.append(layer_idx)
# getting layer globlal informations
self.infos_basics(layer, dico_layer, txt)
# storing layer into the DXF dictionary
dico_dxf['{0}_{1}'.format(layer_idx,
layer.GetName())] = dico_layer
# summing fields number
total_fields += dico_layer.get(u'num_fields')
# summing objects number
total_objs += dico_layer.get(u'num_obj')
# deleting dictionary to ensure having cleared space
del dico_layer
# storing fileds and objects sum
dico_dxf['total_fields'] = total_fields
dico_dxf['total_objs'] = total_objs
def __load_dxf(self):
"""Loads in a dxf file and returns a list of parts
Returns:
list: list of Part
"""
print('Loading file: %s' % self.__fname)
dwg = dxfgrabber.readfile(self.__fname)
lines = [item for item in dwg.entities if item.dxftype == 'LINE']
arcs = [item for item in dwg.entities if item.dxftype == 'ARC']
if self.__layer > -1:
lines = [item for item in lines if item.layer == self.__layer]
arcs = [item for item in arcs if item.layer == self.__layer]
print('File read.')
print('Loaded %i lines' % len(lines))
print('Loaded %i arcs' % len(arcs))
# get all points and Line and Arc using pycalculix entities
all_points, all_lines = self.__get_pts_lines(lines, arcs)
# the index of the point in the set can be used as a hash
lines_from_ptind = {}
for line in all_lines:
ind1 = all_points.index(line.pt(0))
ind2 = all_points.index(line.pt(1))
for ind in [ind1, ind2]:
if ind not in lines_from_ptind:
lines_from_ptind[ind] = [line]
else:
if line not in lines_from_ptind[ind]:
lines_from_ptind[ind].append(line)
# make line loops now
loops = []
line = all_lines[0]
this_loop = geometry.LineLoop()
while len(all_lines) > 0:
this_loop.append(line)
if line in all_lines:
all_lines.remove(line)
point = line.pt(1)
ind = all_points.index(point)
pt_lines = lines_from_ptind[ind]
if line in pt_lines:
pt_lines.remove(line)
if len(pt_lines) == 1:
# we have the next line
next_line = pt_lines[0]
if line.pt(1) != next_line.pt(0):
next_line.reverse()
line = next_line
elif len(pt_lines) > 1:
print('One point was connected to > 2 lines.')
print('Only import simple part loops, or surfaces.')
if this_loop.closed == True:
loops.append(this_loop)
this_loop = geometry.LineLoop()
# check loops to see if one is inside another
# if no loops inside self, then self is a part
# each part in parts is a list of line loops [exterior, hole1, hole2]
parts = []
for ind, loop in enumerate(loops):
other_loops = loops[ind+1:]
is_exterior = True
for other_loop in other_loops:
if loop.inside(other_loop):
is_exterior = False
break
if is_exterior:
# exterior must be clockwise
if loop.ccw == True:
loop.reverse()
parts.append(loop)
# remove the exterior loops from our loops list
for loop in parts:
loops.remove(loop)
# now place the child loops under the part exterior loops
for ind in range(len(parts)):
exterior_loop = parts[ind]
holes = []
# find child holes
for loop in loops:
if loop.inside(exterior_loop):
# holes must be ccw
loop.hole = True
if loop.ccw == False:
loop.reverse()
holes.append(loop)
loop_list = [exterior_loop] + holes
parts[ind] = loop_list
# remove child holes from loop list
for hole in holes:
loops.remove(hole)
# make parts
parts_list = []
for part_loops in parts:
this_part = partmodule.Part(self.__fea)
for ind, loop in enumerate(part_loops):
is_hole = loop.hole
start = loop[0].pt(0)
this_part.goto(start.x, start.y, is_hole)
for item in loop:
if isinstance(item, geometry.Line):
end = item.pt(1)
this_part.draw_line_to(end.x, end.y)
elif isinstance(item, geometry.Arc):
end = item.pt(1)
center = item.actr
this_part.draw_arc(end.x, end.y, center.x, center.y)
parts_list.append(this_part)
print('Parts created: %i' % len(parts_list))
return parts_list
def dxfToPostgis(nameTable, dxfFile):
#dxf = dxfgrabber('KN848832_3_2_I.dxf') # katastralna mapa
dxf = dxfgrabber.readfile(dxfFile) # vykres sa musi nachadzat pri skripte
#entities = dxf.modelspace()
layers = dxf.layers # zoznam pouzitych vrstiev vo vykrese
entities = dxf.entities # zoznam prvkov vo vykrese
#print("DXF version: {}".format(dxf.dxfversion)) # dxf version
header_var_count = len(dxf.header) # dict of dxf header vars
layer_count = len(dxf.layers) # collection of layer definitions
block_definition_count = len(dxf.blocks) # dict like collection of block definitions
entity_count = len(dxf.entities) # list like collection of entities
#print entity_count
connection = psycopg2.connect(DB) # pripoenie k db
connection.autocommit = True
cursor = connection.cursor()
'''
for layer in layers:
layerName = (layer.name).replace("-", "_")
if layerName == '0':
continue
print layerName
'''
cursor.execute("DROP TABLE IF EXISTS " + nameTable)
cursor.execute("CREATE TABLE " + nameTable + " (ID INT NOT NULL, typ CHAR(50),geom GEOMETRY, PRIMARY KEY (ID))")
id = 1
# pocitadla entit
line_count, polyline_count, pw_polyline_count, arc_count, ellipse_count, circle_count, point_count, dsolid, dface_count, k = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
geometry = []
c =1
for entity in entities: # vyber entit podla typu
#print c, entity.dxftype
c=c+1
k=k+1
#print entity.dxftype
'''
if entity.dxftype == "POINT":
point_count = point_count + 1
point = ogr.Geometry(ogr.wkbPoint)
point.AddPoint(entity.point[0], entity.point[1])
wkt = point.ExportToWkt()
cursor.execute("INSERT INTO " + nameTable + " (ID, typ, geom)" + "VALUES (%s, %s, ST_GeometryFromText(%s))",
(id, entity.dxftype, wkt, epsg))
id = id+1
'''
if entity.dxftype == "LINE":
line_count = line_count+1
line = ogr.Geometry(ogr.wkbLineString)
start = entity.start
end = entity.end
#print start, end
line.AddPoint(start[0], start[1], start[2])
line.AddPoint(end[0], end[1], end[2])
wkt = line.ExportToWkt()
cursor.execute("INSERT INTO " + nameTable + " (ID, typ, geom) " + "VALUES(%s, %s, ST_GeometryFromText(%s))",
(id, entity.dxftype, wkt))
id = id + 1
geometry.append(wkt)
elif entity.dxftype == "POLYLINE":
polyline_count = polyline_count+1
vertices = entity.points
vertices_count = len(vertices)
line = ogr.Geometry(ogr.wkbLineString)
for i in range(vertices_count):
line.AddPoint(vertices[i][0],vertices[i][1],vertices[i][2])
wkt = line.ExportToWkt()
cursor.execute("INSERT INTO " + nameTable + " (ID, typ, geom) " + "VALUES(%s, %s, ST_GeometryFromText(%s))",
(id, entity.dxftype, wkt))
id = id + 1
geometry.append(wkt)
elif entity.dxftype == "LWPOLYLINE":
pw_polyline_count = pw_polyline_count+1
vertices = entity.points
vertices_count = len(vertices)
line = ogr.Geometry(ogr.wkbLineString)
for i in range(vertices_count):
line.AddPoint(vertices[i][0],vertices[i][1])
wkt = line.ExportToWkt()
cursor.execute("INSERT INTO " + nameTable + " (ID, typ, geom) " + "VALUES(%s, %s, ST_GeometryFromText(%s))",
(id, entity.dxftype, wkt))
id = id + 1
geometry.append(wkt)
elif entity.dxftype == "ARC":
arc_count = arc_count+1
centerPoint = Point(entity.center[0], entity.center[1], entity.center[2])
#print"arc", centerPoint.getX(), centerPoint.getY(), centerPoint.getZ()
radius = entity.radius
start_angle = entity.start_angle #entity.start_angle
end_angle = entity.end_angle #entity.end_angle
#endPoint = Point(centerPoint.getX()+(radius * m.cos(end_angle)), centerPoint.getY() + (radius * m.sin(end_angle)), entity.center[2])
line = ogr.Geometry(ogr.wkbLineString)
range_angle = end_angle-start_angle
if range_angle < 0:
range_angle = range_angle+(360)
while start_angle < (entity.start_angle+range_angle):
p = Point(centerPoint.getX()+(radius * m.cos(m.radians(start_angle))), centerPoint.getY()+(radius * m.sin(m.radians(start_angle))), entity.center[2])
line.AddPoint(p.getX(), p.getY())
start_angle = start_angle + m.radians(1)
wkt = line.ExportToWkt()
#print wkt
cursor.execute("INSERT INTO " + nameTable + " (ID, typ, geom)" + "VALUES(%s, %s, ST_GeometryFromText(%s))",
(id, entity.dxftype, wkt))
id = id + 1
geometry.append(wkt)
elif entity.dxftype == "ELLIPSE":
ellipse_count = ellipse_count+1
centerPoint = Point(entity.center[0], entity.center[1], entity.center[2])
majorAxisPoint = Point(entity.major_axis[0], entity.major_axis[1], entity.major_axis[2])
start_param = entity.start_param
end_param = entity.end_param
line = ogr.Geometry(ogr.wkbLineString)
#print "start_par: ", start_param, "end_param: ", end_param
#print "ellipse center point x = {0}, y = {1}, z = {2}".format(centerPoint.getX(), centerPoint.getY(), centerPoint.getZ())
#print "major axis: ", majorAxisPoint.getX(), majorAxisPoint.getY()
endPointMajorAxis = Point(centerPoint.getX() + majorAxisPoint.getX(), centerPoint.getY() + majorAxisPoint.getY())
#print "end Point Major axis:",endPointMajorAxis.getX(), endPointMajorAxis.getY()
#print "ratio:", entity.ratio
ratio = entity.ratio
a = m.sqrt(majorAxisPoint.getX()*majorAxisPoint.getX() + majorAxisPoint.getY()*majorAxisPoint.getY())
b = a*ratio
azimut = fCalculateAzimuth(centerPoint.getX(), centerPoint.getY(), endPointMajorAxis.getX(), endPointMajorAxis.getY())
if round(end_param,5) == round(2*pi,5) and round(start_param,5) <> round(0.0,5): # ak by nebolo -pi elipsa je o pi otocena dovod - zatial neznami
end_param = start_param - pi
start_param = 0
a=0
while start_param <= end_param:
xi = a * m.cos(start_param)
yi = b * m.sin(start_param)
xe = m.sin(m.radians(azimut))*xi - m.cos(m.radians(azimut))*yi
ye = m.sin(m.radians(azimut))*yi + m.cos(m.radians(azimut))*xi
if (end_param-start_param) < m.radians(1):
start_param = start_param + (end_param-start_param)
start_param = start_param + a
a=1
else:
start_param = start_param+m.radians(1)
p = Point(centerPoint.getX() + xe, centerPoint.getY() + ye)
line.AddPoint(p.getX(), p.getY())
#print p.getX(), p.getY()
wkt = line.ExportToWkt()
print wkt
cursor.execute("INSERT INTO " + nameTable + " (ID, typ, geom)" + "VALUES(%s, %s, ST_GeometryFromText(%s))",
(id, entity.dxftype, wkt))
id = id + 1
geometry.append(wkt)
elif entity.dxftype == "CIRCLE":
circle_count = circle_count+1
radius = entity.radius
centerPoint = Point(entity.center[0], entity.center[1], entity.center[2])
line = ogr.Geometry(ogr.wkbLineString)
i = 0
while i <= 2*pi:
p = Point(centerPoint.getX()+(radius * m.cos(i)), centerPoint.getY()+(radius * m.sin(i)), entity.center[2])
line.AddPoint(p.getX(), p.getY())
i = i + m.radians(1)
wkt = line.ExportToWkt()
cursor.execute("INSERT INTO " + nameTable + " (ID, typ, geom)" + "VALUES(%s, %s, ST_GeometryFromText(%s))",
(id, entity.dxftype, wkt))
id = id + 1
geometry.append(wkt)
cursor.execute("DROP INDEX IF EXISTS " + nameTable + "_index")
cursor.execute("CREATE INDEX " + nameTable + "_index ON test USING GIST(geom)")
#else:
# print k, entity.dxftype
'''
print "count line %i" % line_count
print "count polyline %i" % polyline_count
print "count pwpolyline %i" % pw_polyline_count
print "count arc %i" % arc_count
print "count ellipse %i" % ellipse_count
#print "count 3Dsolid %i" % dsolid_count
#print "count 3Dface %i" % dface_count
print "count circle %i" % circle_count
print "count point %i" % point_count
print line_count+polyline_count+pw_polyline_count+arc_count+ellipse_count+circle_count
print len(geometry)
'''
return geometry
def main():
# Connect to arduino
device = "/dev/ttyAMC1"
try:
ser = serial.Serial(device, PORT)
except serial.SerialException:
ser = serial.Serial('/dev/ttyACM0', PORT)
#print 'Oops, couldn\'t connect to the Arduino'
#print 'is it plugged in?'
#print 'did you set the right DEVICE and PORT in this file?'
#exit()
# Wait for arduino to connect
time.sleep(2)
print 'Connected'
# Open dxf file
filename = 'line.dxf'
dxf = dxfgrabber.readfile(filename)
lines = [ [],[],[],[] ]
print 'x1 x2 y1 y2'
# Get lines
for entity in dxf.entities:
x1,y1 = entity.start
x2,y2 = entity.end
print x1,x2,y1,y2
lines[0].append(x1)
lines[1].append(x2)
lines[2].append(y1)
lines[3].append(y2)
# shift drawing so that origin is at 0,0
x1Min = min(lines[0])
x2Min = min(lines[1])
y1Min = min(lines[2])
y2Min = min(lines[3])
xMin = min([x1Min, x2Min])
yMin = min([y1Min, y2Min])
lines[0] = [el - xMin for el in lines[0]]
lines[1] = [el - xMin for el in lines[1]]
lines[2] = [el - yMin for el in lines[2]]
lines[3] = [el - yMin for el in lines[3]]
# Scale drawing so that maximum dimension is MAXDIM
x1Max = max(lines[0])
x2Max = max(lines[1])
y1Max = max(lines[2])
y2Max = max(lines[3])
Max = max([x1Max, x2Max, y1Max, y2Max])
lines[0] = [ (el)*(MAXDIM/Max)+xStart for el in lines[0] ]
lines[1] = [ (el)*(MAXDIM/Max)+xStart for el in lines[1] ]
lines[2] = [ (el)*(MAXDIM/Max)+yStart for el in lines[2] ]
lines[3] = [ (el)*(MAXDIM/Max)+yStart for el in lines[3] ]
# Invert y coordinate because 'y' is backwards on board
lines[2] = [ e *(-1) for e in lines[2] ]
lines[3] = [ e *(-1) for e in lines[3] ]
print 'after'
# Draw lines
for x1,x2,y1,y2 in zip(lines[0],lines[1],lines[2],lines[3]):
print x1,x2,y1,y2
# The A is to verify that a real signal has been sent
ser.write(str(int(x1))+','+str(int(x2))+','+str(int(y1))+','+str(int(y2))+'\n')
# Wait for the arduino to finish the line or break after a while
millis = int(round(time.time() * 1000))
print millis
while(1):
try:
# TODO: wrap this call in something that will kill it if it's
# not done in a few milliseconds
waitline = ser.read()
except: # serial.SerialException:
print "Something wrong with serial connection?"
break
finally:
break
if waitline == "a":
break
current_millis = int(round(time.time() * 1000))
# Timeout condition
print current_millis
if current_millis > millis + 2000:
print "Timeout"
break
footer = """)
"""
# draw a line
# (from http://www.compuphase.com/electronics/LibraryFileFormats.pdf)
def make_line(x0, y0, x1, y1):
return """ (fp_line
(start %(0)s %(1)s)
(end %(2)s %(3)s)
(layer Edge.Cuts)
(width %(4)0.2f)
)
""" % {"0":x0, "1":y0, "2":x1, "3":y1, "4":args.width[0]}
def conv_dxf_to_module(module_name, entities):
module = header % {"name": module_name}
for entity in entities:
if entity.dxftype == "LINE":
module += make_line(entity.start[0], entity.start[1], entity.end[0], entity.end[1])
module += footer % {"name": module_name}
return module
dxf = dxfgrabber.readfile(args.inputfile)
header_var_count = len(dxf.header)
layer_count = len(dxf.layers)
entity_count = len(dxf.entities)
outfile=open(args.outputfile, 'w')
outfile.write(conv_dxf_to_module("DP5050", dxf.entities))
outfile.close()
if layer.on and not layer.frozen:
handleEntity(svgFile, entity)
else:
print "Not handeling entity " + str(entity)
svgFile.write('</svg>\n')
#end: saveToSVG
if __name__ == '__main__':
# TODO: error handling
if len(sys.argv) < 2:
sys.exit('Usage: {0} file-name'.format(sys.argv[0]))
for filename in sys.argv[1:]:
# grab data from file
dxfData = dxfgrabber.readfile(filename)
# convert and save to svg
svgName = '.'.join([os.path.splitext(filename)[0]] + ['svg'])
if os.path.exists(svgName):
if not raw_input("Overwrite existing file? (y/N) ").lower() == 'y':
quit("Quitting.")
svgFile = open(svgName, 'w')
label_basename = os.path.basename(filename).split('_')[0]
print("Opening '%s' (%s)" % (filename, label_basename))
print "Saving to SVG file: {0}".format(svgName)
saveToSVG(svgFile, dxfData)
x0 = (B*B + L1*L1 - L2*L2)/(2*B)
y0 = math.sqrt(L2*L2 - (B - x0)*(B - x0))
L1new = math.sqrt((x + x0)*(x + x0) + (y +y0)*(y +y0))
L2new = math.sqrt((B - (x + x0))*(B - (x + x0)) + (y +y0)*(y +y0))
L1corrected = - (L1new - L1)
L2corrected = - (L2new - L2)
return L1corrected, L2corrected
#This opens a file dialog for choosing a .dxf file to import.
if __name__ == '__main__':
root = Tkinter.Tk()
root.withdraw()
file = tkFileDialog.askopenfilename(filetypes=[("DXF files","*.dxf")], title="Import DXF file",parent=root)
dxf = dxfgrabber.readfile(file)
all_lines = [entity for entity in dxf.entities if entity.dxftype == 'LINE']
NoofLines = len(all_lines)
#Sets the origin and further magnitude of speed for the plotting in units mm/minute.
gcode = 'G1 ' + 'X 0.0000 ' + 'Y 0.0000 ' + 'Z 0.0000 F 3000 \n' + 'G1 ' + 'X 0.0000 ' + 'Y 0.0000 ' + 'Z 0.3000 \n'
for x in range(len(all_lines)):
if x == 0:
gcode = gcode + 'G1 ' + 'X ' + str(cartesianTodrawbot(all_lines[x].start[0],all_lines[x].start[1],B, L1, L2)[0]) + ' Y ' + str(cartesianTodrawbot(all_lines[x].start[0],all_lines[x].start[1],B, L1, L2)[1]) + ' Z 0.3000 \n'
else:
if all_lines[x-1].end[0] == all_lines[x].start[0] and all_lines[x-1].end[1] == all_lines[x].start[1]:
gcode = gcode + 'G1 ' + 'X ' + str(cartesianTodrawbot(all_lines[x].start[0],all_lines[x].start[1],B, L1, L2)[0]) + ' Y ' + str(cartesianTodrawbot(all_lines[x].start[0],all_lines[x].start[1],B, L1, L2)[1]) + ' Z 0.0000 \n'
else:
gcode = gcode + 'G1 ' + 'X ' + str(cartesianTodrawbot(all_lines[x].start[0],all_lines[x].start[1],B, L1, L2)[0]) + ' Y ' + str(cartesianTodrawbot(all_lines[x].start[0],all_lines[x].start[1],B, L1, L2)[1]) + ' Z 0.3000 \n'
def create_script(dxf_file, script_file, layers, scale_factor=1, offset=(0,0), spline_point_scalar = 50):
"""
Create an EAGLE script from a DXF file.
:param dxf_file: The path to the input DXF file.
:param script_file: The path to the output EAGLE script.
:param layers: A ``dict`` of layers which should be converted, or ``None`` if all layers should be converted.
:param scale_factor: The factor by which to scale the output.
:param offset: A two-element tuple specifying the amount by which to offset the output.
:param spline_point_scalar: The factor by which to multiply the number of spline control points to yield the total number of spline approximation points.
:returns: ``None``.
"""
# Read the input DXF file
dxf = dxfgrabber.readfile(dxf_file)
# Open the output EAGLE script file
f = open(script_file, 'w')
# Initialize counters to hold the number of primitives by type.
num_arcs = 0
num_circles = 0
num_lines = 0
num_polylines = 0
num_splines = 0
num_text = 0
last_text_size = None
# Iterate through the entities
for e in dxf.entities:
if layers == None or layers.has_key(e.layer):
if isinstance(e, dxfgrabber.entities.Arc):
add_arc(f, e.center[0]*scale_factor + offset[0],
e.center[1]*scale_factor + offset[1],
e.radius*scale_factor,
e.startangle,
e.endangle)
num_arcs += 1
elif isinstance(e, dxfgrabber.entities.Circle):
add_circle(f, e.center[0]*scale_factor + offset[0], e.center[1]*scale_factor + offset[1], e.radius * scale_factor)
num_circles += 1
elif isinstance(e, dxfgrabber.entities.Line):
add_line(f, e.start[0] * scale_factor + offset[0], e.start[1] * scale_factor + offset[1], e.end[0] * scale_factor + offset[0], e.end[1] * scale_factor + offset[1])
num_lines += 1
elif isinstance(e, dxfgrabber.entities.Polyline):
for i in range(1, len(e.vertices)):
add_line(f, e.vertices[i-1].location[0] * scale_factor + offset[0],
e.vertices[i-1].location[1] * scale_factor + offset[1],
e.vertices[i].location[0] * scale_factor + offset[0],
e.vertices[i].location[1] * scale_factor + offset[1])
num_polylines += 1
elif isinstance(e, dxfgrabber.entities.Spline):
p = e.degree
P = e.controlpoints
U = e.knots
num_points = spline_point_scalar * len(P)
step = (U[-1] - U[0]) / float(num_points)
points = []
for i in range(num_points):
u = U[0] + step * i
xy = bezier.deboor(P, U, u, p)
points.append(xy)
xy = bezier.deboor(P, U, U[-1] - step*0.01, p)
points.append(xy)
for i in range(len(points)-1):
add_line(f, points[i][0] * scale_factor + offset[0],
points[i][1] * scale_factor + offset[1],
points[i+1][0] * scale_factor + offset[0],
points[i+1][1] * scale_factor + offset[1])
num_splines += 1
elif isinstance(e, dxfgrabber.entities.Text):
h = e.height * scale_factor
if h != last_text_size:
add_set(f, 'size', h)
last_text_size = h
add_text(f, e.insert[0] * scale_factor + offset[0],
e.insert[1] * scale_factor + offset[1],
e.rotation,
e.text)
num_text += 1
elif isinstance(e, dxfgrabber.entities.MText):
# lines = e.lines()
#
# # The defualt spacing between two baselines is 5/3 the height of the text
# default_spacing = 5/3.0
#
# # Thus, the text height is 1,
# # the descender is 1/3.0
# # the ascender is 1/3.0
#
# # This can be overriden by the linespacing property
# spacing = e.linespacing * default_spacing * scale_factor
#
# # The total height is the total number of lines multiplied by the spacing
# total_height = len(lines) * spacing
#
# # The attachment points are:
#
pass
# lines = e.lines()
#
# # The default spacing between two baselines is 5/3 the height of the text
# default_spacing = 5 / 3.0
#
# # This can be overriden by the linespacing property
# spacing = e.linespacing * default_spacing * scale_factor
# h = e.height * scale_factor
#
# total_height = h + (len(lines) - 1) * spacing
#
# x_base = e.insert[0] * scale_factor + offset[0]
# y_base = e.insert[1] * scale_factor + offset[1]
#
# if (e.attachmentpoint >= 1 and e.attachmentpoint <= 3):
# # Attachment point is top
# y = y_base
# elif (e.attachmentpoint >= 4 and e.attachmentpoint <= 6):
# # Attachment point is middle
# pass
# elif (e.attachmentpoint >= 7 and e.attachmentpoint <= 8):
# # Attachment point is bottom
# pass
# else:
# raise Exception("Invalid text attachment point {0}.".format(e.attachmentpoint))
else:
print('Got unknown element {0}'.format(e))
f.close()
print("Script written successfully.")
print("{0} arcs".format(num_arcs))
print("{0} circles".format(num_circles))
print("{0} lines".format(num_lines))
print("{0} polylines".format(num_polylines))
print("{0} splines".format(num_splines))
print("{0} text".format(num_text))
import dxfgrabber
drawing = dxfgrabber.readfile("F:\\Egyetem\\Diplomamunka\\bottle_opener.dxf")
print("DXF version: {}".format(drawing.dxfversion))
print("Encoding: {}".format(drawing.encoding))
print("Entities: {}".format(drawing.entities))
# dict of dxf header vars
header_var_count = len(drawing.header)
# collection of layer definitions
layer_count = len(drawing.layers)
# dict like collection of block definitions
block_definition_count = len(drawing.blocks)
entitiy_count = len(drawing.entities)
references = ([entity for entity in drawing.entities
if entity.dxftype == 'INSERT'])
for block in drawing.blocks:
print("block name: {}".format(block.name))
print("block basepoint: {}".format(block.basepoint))
print("block xrefpath: {}".format(block.xrefpath))
print("\n")
for entity in drawing.entities:
print("entity name: {}".format(entity.name))
print("entity type: {}".format(entity.dxftype))
print("insert insert: {}".format(entity.insert))
print("insert rotation: {}".format(entity.rotation))
print("insert scale: {}".format(entity.scale))
print("insert attribs: {}".format(entity.attribs))
print("entity layer: {}".format(entity.layer))
def _layer_entities(entities):
seq = list(entities)
seq.sort(key=lambda e: e.layer)
groups = groupby(seq, lambda e: e.layer)
return groups
def cmds_from_entities(entities):
'''
get all cmd (in kicad_mod_format) from entities which is the entities
on all layers.
'''
return functools.reduce(lambda x, y: x+y,
(list(fp_polys(layer, entities))
for (layer, entities) in
_layer_entities(dxf.entities)))
if __name__ == '__main__':
if len(sys.argv) < 2:
print('usage:\n'
' save to a file: python {} '
'inputfile.dxf > outputfile.kicad_mod\n'
' print to stdout: python {} inputfile.dxf'.format(
sys.argv[0], sys.argv[0]))
else:
dxf = dxfgrabber.readfile(sys.argv[1])
print(str(kf.Module('autogenerated',
children=cmds_from_entities(dxf.entities))))
def calcOpeningBoundingBox(abs_file_path, WINDOW_LAYER_NAME, DOOR_LAYER_NAME):
dxf = dxfgrabber.readfile(abs_file_path, {"grab_blocks":True, "assure_3d_coords":False, "resolve_text_styles":False})
windows=[]
doors=[]
for i in dxf.entities:
# -------------------------------- Windows ------------------------------------
if i.layer == WINDOW_LAYER_NAME and i.dxftype == 'INSERT':
X0=i.insert[0]
Y0=i.insert[1]
angle=math.radians(i.rotation)
xs=i.scale[0]
ys=i.scale[1]
result=blockbbox(i, dxf, X0, Y0, angle, xs, ys)
p1=result[0]
p2=result[1]
p3=result[2]
p4=result[3]
if p1.distance(p2)>=p2.distance(p3):
pp1,pp2=extend_line_bothdir(Point((p1.x+p4.x)/2, (p1.y+p4.y)/2), Point((p2.x+p3.x)/2, (p2.y+p3.y)/2), 20)
width=p2.distance(p3)
length=Point((p1.x+p4.x)/2, (p1.y+p4.y)/2).distance(Point((p2.x+p3.x)/2, (p2.y+p3.y)/2))
else:
pp1,pp2=extend_line_bothdir(Point((p1.x+p2.x)/2, (p1.y+p2.y)/2), Point((p3.x+p4.x)/2, (p3.y+p4.y)/2), 20)
width=p1.distance(p2)
length=Point((p1.x+p2.x)/2, (p1.y+p2.y)/2).distance(Point((p3.x+p4.x)/2, (p3.y+p4.y)/2))
windows.append(Window(LineString([(pp1.x,pp1.y),(pp2.x,pp2.y)]), width, length))
# --------------------------------- Doors -------------------------------------
if i.layer == DOOR_LAYER_NAME and i.dxftype == 'INSERT':
X0=i.insert[0]
Y0=i.insert[1]
angle=math.radians(i.rotation)
xs=i.scale[0]
ys=i.scale[1]
result=blockbbox(i, dxf, X0, Y0, angle, xs, ys)
p1=result[0]
p2=result[1]
p3=result[2]
p4=result[3]
if p1.distance(p2)>=p2.distance(p3):
pp1,pp2=extend_line_bothdir(Point((p1.x+p4.x)/2, (p1.y+p4.y)/2), Point((p2.x+p3.x)/2, (p2.y+p3.y)/2), 20)
width=p2.distance(p3)
length=Point((p1.x+p4.x)/2, (p1.y+p4.y)/2).distance(Point((p2.x+p3.x)/2, (p2.y+p3.y)/2))
else:
pp1,pp2=extend_line_bothdir(Point((p1.x+p2.x)/2, (p1.y+p2.y)/2), Point((p3.x+p4.x)/2, (p3.y+p4.y)/2), 20)
width=p1.distance(p2)
length=Point((p1.x+p2.x)/2, (p1.y+p2.y)/2).distance(Point((p3.x+p4.x)/2, (p3.y+p4.y)/2))
doors.append(Door(LineString([(pp1.x,pp1.y),(pp2.x,pp2.y)]), width, length))
#------------------------------------------------------------------------------
print '#-----------------------------'
print 'len(windows)', len(windows)
print 'len(doors)', len(doors)
openings=[]
openings.extend(windows)
openings.extend(doors)
return openings
def rdxf(filename):
dxf = dxfgrabber.readfile(filename)
total_length = 0
########################################
# Info
########################################
log("DXF version: {}".format(dxf.dxfversion))
# dict of dxf header vars
log('header_var_coun: {}'.format(len(dxf.header)))
# collection of layer definitions
log('layer_count: {}'.format(len(dxf.layers)))
# dict like collection of block definitions
log('block_definition_count'.format(len(dxf.blocks)))
# list like collection of entities
log('entity_count: {}'.format(len(dxf.entities)))
log('')
########################################
# Entities
########################################
for e in dxf.entities:
typename = e.dxftype
log('=' * 20)
log('DXF Entity: {}\n'.format(typename))
if typename == 'LWPOLYLINE':
#print('LWPolyline is closed? {}\n'.format(e.closed))
length = None
ppoint = (0, 0)
for p in e.points:
log(p)
if length is None:
length = 0
ppoint = p
continue
length += euclidean_distance(ppoint, p)
ppoint = p
log('Length = {}\n'.format(length))
total_length += length
elif typename == 'LINE':
log('LINE on layer: {}\n'.format(e.dxf.layer))
log('start point: {}\n'.format(e.dxf.start))
log('end point: {}\n'.format(e.dxf.end))
length = euclidean_distance(e.start, e.end)
log('Length = {}\n'.format(length))
total_length += length
elif typename == 'ELLIPSE':
a = euclidean_distance((0, 0), e.majoraxis)
b = a * e.ratio
log('center: {}'.format(e.center))
log('majoraxis: {}'.format(e.majoraxis))
log('a: {}'.format(a))
log('b: {}'.format(b))
length = ellipse(a, b)
log('distance: {}'.format(length))
total_length += length
elif typename == 'SPLINE':
print(e.__dict__)
pass
else:
print('Not Implemented')
log('=' * 20)
speed = 4
log('{} mm / {} mmps = {} s'.format(total_length, speed, total_length / speed))
import dxfgrabber
import svgwrite
import math
dxf = dxfgrabber.readfile("map.dxf")
svg = svgwrite.Drawing()
class Line(object):
def __init__(self, letter, dxf_color):
self.letter = letter
self.dxf_color = dxf_color
self.line_svg_layer = svg.g(id="line-" + letter)
self.hollow_svg_layer = svg.g(id="line-" + letter + "-hollow")
# We use DXF colors as a proxy for line designation.
# These don't actually match the colors we use in the final
# rendered map.
# The order in this list dictates the layering order in the
# map rendering, with the first item deepest.
line_stack = [
Line("T", 1),
Line("L", 9),
Line("A", 5),
Line("B", 3),
Line("K", 2),
Line("R", 40),
