svn-gvsig-desktop / trunk / libraries / libDwg / src / com / iver / cit / jdwglib / dwg / DwgFile.java @ 2896
History | View | Annotate | Download (48.7 KB)
1 |
/* jdwglib. Java Library for reading Dwg files.
|
---|---|
2 |
*
|
3 |
* Author: Jose Morell Rama (jose.morell@gmail.com).
|
4 |
* Port from the Pythoncad Dwg library by Art Haas.
|
5 |
*
|
6 |
* Copyright (C) 2005 Jose Morell, IVER TI S.A. and Generalitat Valenciana
|
7 |
*
|
8 |
* This program is free software; you can redistribute it and/or
|
9 |
* modify it under the terms of the GNU General Public License
|
10 |
* as published by the Free Software Foundation; either version 2
|
11 |
* of the License, or (at your option) any later version.
|
12 |
*
|
13 |
* This program is distributed in the hope that it will be useful,
|
14 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
15 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
16 |
* GNU General Public License for more details.
|
17 |
*
|
18 |
* You should have received a copy of the GNU General Public License
|
19 |
* along with this program; if not, write to the Free Software
|
20 |
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,USA.
|
21 |
*
|
22 |
* For more information, contact:
|
23 |
*
|
24 |
* Jose Morell (jose.morell@gmail.com)
|
25 |
*
|
26 |
* or
|
27 |
*
|
28 |
* IVER TI S.A.
|
29 |
* C/Salamanca, 50
|
30 |
* 46005 Valencia
|
31 |
* Spain
|
32 |
* +34 963163400
|
33 |
* dac@iver.es
|
34 |
*/
|
35 |
package com.iver.cit.jdwglib.dwg; |
36 |
|
37 |
import java.awt.geom.Point2D; |
38 |
import java.io.File; |
39 |
import java.io.FileInputStream; |
40 |
import java.io.IOException; |
41 |
import java.nio.ByteBuffer; |
42 |
import java.nio.channels.FileChannel; |
43 |
import java.util.Vector; |
44 |
|
45 |
import com.iver.cit.javacad.util.AcadExtrusionCalculator; |
46 |
import com.iver.cit.javacad.util.GisModelCurveCalculator; |
47 |
import com.iver.cit.jdwglib.dwg.objects.DwgArc; |
48 |
import com.iver.cit.jdwglib.dwg.objects.DwgAttdef; |
49 |
import com.iver.cit.jdwglib.dwg.objects.DwgAttrib; |
50 |
import com.iver.cit.jdwglib.dwg.objects.DwgBlock; |
51 |
import com.iver.cit.jdwglib.dwg.objects.DwgBlockControl; |
52 |
import com.iver.cit.jdwglib.dwg.objects.DwgBlockHeader; |
53 |
import com.iver.cit.jdwglib.dwg.objects.DwgCircle; |
54 |
import com.iver.cit.jdwglib.dwg.objects.DwgEllipse; |
55 |
import com.iver.cit.jdwglib.dwg.objects.DwgEndblk; |
56 |
import com.iver.cit.jdwglib.dwg.objects.DwgInsert; |
57 |
import com.iver.cit.jdwglib.dwg.objects.DwgLayer; |
58 |
import com.iver.cit.jdwglib.dwg.objects.DwgLayerControl; |
59 |
import com.iver.cit.jdwglib.dwg.objects.DwgLine; |
60 |
import com.iver.cit.jdwglib.dwg.objects.DwgLinearDimension; |
61 |
import com.iver.cit.jdwglib.dwg.objects.DwgLwPolyline; |
62 |
import com.iver.cit.jdwglib.dwg.objects.DwgMText; |
63 |
import com.iver.cit.jdwglib.dwg.objects.DwgPoint; |
64 |
import com.iver.cit.jdwglib.dwg.objects.DwgPolyline2D; |
65 |
import com.iver.cit.jdwglib.dwg.objects.DwgPolyline3D; |
66 |
import com.iver.cit.jdwglib.dwg.objects.DwgSeqend; |
67 |
import com.iver.cit.jdwglib.dwg.objects.DwgSolid; |
68 |
import com.iver.cit.jdwglib.dwg.objects.DwgSpline; |
69 |
import com.iver.cit.jdwglib.dwg.objects.DwgText; |
70 |
import com.iver.cit.jdwglib.dwg.objects.DwgVertex2D; |
71 |
import com.iver.cit.jdwglib.dwg.objects.DwgVertex3D; |
72 |
|
73 |
/**
|
74 |
* The DwgFile class provides a revision-neutral interface for reading and handling
|
75 |
* DWG files
|
76 |
* Reading methods are useful for reading DWG files, and handling methods like
|
77 |
* calculateDwgPolylines() are useful for handling more complex
|
78 |
* objects in the DWG file
|
79 |
*
|
80 |
* @author jmorell
|
81 |
*/
|
82 |
public class DwgFile { |
83 |
private String fileName; |
84 |
private String dwgVersion; |
85 |
private Vector dwgSectionOffsets; |
86 |
private Vector dwgObjectOffsets; |
87 |
private Vector dwgObjects; |
88 |
private Vector dwgClasses; |
89 |
private DwgFileReader dwgReader;
|
90 |
private Vector layerTable; |
91 |
private boolean dwg3DFile; |
92 |
|
93 |
/**
|
94 |
* Creates a new DwgFile object given the absolute path to
|
95 |
* a DWG file
|
96 |
*
|
97 |
* @param fileName an absolute path to the DWG file
|
98 |
*/
|
99 |
public DwgFile(String fileName) { |
100 |
this.fileName = fileName;
|
101 |
dwgSectionOffsets = new Vector(); |
102 |
dwgObjectOffsets = new Vector(); |
103 |
dwgObjects = new Vector(); |
104 |
dwgClasses = new Vector(); |
105 |
} |
106 |
|
107 |
/**
|
108 |
* Reads a DWG file and put its objects in the dwgObjects Vector
|
109 |
* This method is version independent
|
110 |
*
|
111 |
* @throws IOException If the file location is wrong
|
112 |
*/
|
113 |
public void read() throws IOException{ |
114 |
System.out.println("DwgFile.read() executed ..."); |
115 |
setDwgVersion(); |
116 |
if (dwgVersion.equals("R13")) { |
117 |
dwgReader = new DwgFileV14Reader();
|
118 |
dwgReader.read(this);
|
119 |
} else if (dwgVersion.equals("R14")) { |
120 |
dwgReader = new DwgFileV14Reader();
|
121 |
dwgReader.read(this);
|
122 |
} else if (dwgVersion.equals("R15")) { |
123 |
dwgReader = new DwgFileV15Reader();
|
124 |
dwgReader.read(this);
|
125 |
} else if (dwgVersion.equals("Unknown")) { |
126 |
System.out.println("ERROR: Dwg version not supported"); |
127 |
} |
128 |
} |
129 |
|
130 |
/**
|
131 |
* Modify the geometry of the objects applying the Extrusion vector where it
|
132 |
* is necessary
|
133 |
*/
|
134 |
public void applyExtrusions() { |
135 |
for (int i=0;i<dwgObjects.size();i++) { |
136 |
DwgObject dwgObject = (DwgObject)dwgObjects.get(i); |
137 |
if (dwgObject instanceof DwgArc) { |
138 |
double[] arcCenter = ((DwgArc)dwgObject).getCenter(); |
139 |
double[] arcExt = ((DwgArc)dwgObject).getExtrusion(); |
140 |
arcCenter = AcadExtrusionCalculator.CalculateAcadExtrusion(arcCenter, arcExt); |
141 |
((DwgArc)dwgObject).setCenter(arcCenter); |
142 |
} else if (dwgObject instanceof DwgAttdef) { |
143 |
// Extrusion in DwgAttdef is not necessary
|
144 |
} else if (dwgObject instanceof DwgAttrib) { |
145 |
Point2D attribInsertionPoint = ((DwgAttrib)dwgObject).getInsertionPoint();
|
146 |
double attribElevation = ((DwgAttrib)dwgObject).getElevation();
|
147 |
double[] attribInsertionPoint3D = new double[]{attribInsertionPoint.getX(), attribInsertionPoint.getY(), attribElevation}; |
148 |
double[] attribExt = ((DwgAttrib)dwgObject).getExtrusion(); |
149 |
attribInsertionPoint3D = AcadExtrusionCalculator.CalculateAcadExtrusion(attribInsertionPoint3D, attribExt); |
150 |
((DwgAttrib)dwgObject).setInsertionPoint(new Point2D.Double(attribInsertionPoint3D[0], attribInsertionPoint3D[1])); |
151 |
((DwgAttrib)dwgObject).setElevation(attribInsertionPoint3D[2]);
|
152 |
} else if (dwgObject instanceof DwgBlock) { |
153 |
// DwgBlock hasn't Extrusion
|
154 |
} else if (dwgObject instanceof DwgBlockControl) { |
155 |
// DwgBlockControl hasn't Extrusion
|
156 |
} else if (dwgObject instanceof DwgBlockHeader) { |
157 |
// DwgBlockHeader hasn't Extrusion
|
158 |
} else if (dwgObject instanceof DwgCircle) { |
159 |
double[] circleCenter = ((DwgCircle)dwgObject).getCenter(); |
160 |
double[] circleExt = ((DwgCircle)dwgObject).getExtrusion(); |
161 |
circleCenter = AcadExtrusionCalculator.CalculateAcadExtrusion(circleCenter, circleExt); |
162 |
((DwgCircle)dwgObject).setCenter(circleCenter); |
163 |
// Seems that Autocad don't apply the extrusion to Ellipses
|
164 |
/*} else if (dwgObject instanceof DwgEllipse) {
|
165 |
double[] ellipseCenter = ((DwgEllipse)dwgObject).getCenter();
|
166 |
double[] ellipseExt = ((DwgEllipse)dwgObject).getExtrusion();
|
167 |
ellipseCenter = AcadExtrusionCalculator.CalculateAcadExtrusion(ellipseCenter, ellipseExt);
|
168 |
((DwgEllipse)dwgObject).setCenter(ellipseCenter);*/
|
169 |
} else if (dwgObject instanceof DwgInsert) { |
170 |
double[] insertPoint = ((DwgInsert)dwgObject).getInsertionPoint(); |
171 |
double[] insertExt = ((DwgInsert)dwgObject).getExtrusion(); |
172 |
insertPoint = AcadExtrusionCalculator.CalculateAcadExtrusion(insertPoint, insertExt); |
173 |
((DwgInsert)dwgObject).setInsertionPoint(insertPoint); |
174 |
} else if (dwgObject instanceof DwgLayer) { |
175 |
// DwgLayer hasn't Extrusion
|
176 |
} else if (dwgObject instanceof DwgLayerControl) { |
177 |
// DwgLayerControl hasn't Extrusion
|
178 |
} else if (dwgObject instanceof DwgLine) { |
179 |
double[] lineP1 = ((DwgLine)dwgObject).getP1(); |
180 |
double[] lineP2 = ((DwgLine)dwgObject).getP2(); |
181 |
boolean zflag = ((DwgLine)dwgObject).isZflag();
|
182 |
if (zflag) {
|
183 |
// elev = 0.0;
|
184 |
lineP1 = new double[]{lineP1[0], lineP1[1], 0.0}; |
185 |
lineP2 = new double[]{lineP2[0], lineP2[1], 0.0}; |
186 |
} |
187 |
double[] lineExt = ((DwgLine)dwgObject).getExtrusion(); |
188 |
lineP1 = AcadExtrusionCalculator.CalculateAcadExtrusion(lineP1, lineExt); |
189 |
lineP2 = AcadExtrusionCalculator.CalculateAcadExtrusion(lineP2, lineExt); |
190 |
((DwgLine)dwgObject).setP1(lineP1); |
191 |
((DwgLine)dwgObject).setP2(lineP2); |
192 |
} else if (dwgObject instanceof DwgLinearDimension) { |
193 |
// TODO: Extrusions in DwgLinearDimension elements
|
194 |
// TODO: Void LwPolylines are a bug
|
195 |
} else if (dwgObject instanceof DwgLwPolyline && ((DwgLwPolyline)dwgObject).getVertices()!=null) { |
196 |
Point2D[] vertices = ((DwgLwPolyline)dwgObject).getVertices(); |
197 |
double[] lwPolylineExt = ((DwgLwPolyline)dwgObject).getNormal(); |
198 |
// Normals and Extrusions aren`t the same
|
199 |
if (lwPolylineExt[0]==0 && lwPolylineExt[1]==0 && lwPolylineExt[2]==0) lwPolylineExt[2] = 1.0; |
200 |
double elev = ((DwgLwPolyline)dwgObject).getElevation();
|
201 |
double[][] lwPolylinePoints3D = new double[vertices.length][3]; |
202 |
for (int j=0;j<vertices.length;j++) { |
203 |
lwPolylinePoints3D[j][0] = vertices[j].getX();
|
204 |
lwPolylinePoints3D[j][1] = vertices[j].getY();
|
205 |
lwPolylinePoints3D[j][2] = elev;
|
206 |
lwPolylinePoints3D[j] = AcadExtrusionCalculator.CalculateAcadExtrusion(lwPolylinePoints3D[j], lwPolylineExt); |
207 |
} |
208 |
((DwgLwPolyline)dwgObject).setElevation(elev); |
209 |
for (int j=0;j<vertices.length;j++) { |
210 |
vertices[j] = new Point2D.Double(lwPolylinePoints3D[j][0], lwPolylinePoints3D[j][1]); |
211 |
} |
212 |
((DwgLwPolyline)dwgObject).setVertices(vertices); |
213 |
} else if (dwgObject instanceof DwgMText) { |
214 |
double[] mtextPoint = ((DwgMText)dwgObject).getInsertionPoint(); |
215 |
double[] mtextExt = ((DwgMText)dwgObject).getExtrusion(); |
216 |
mtextPoint = AcadExtrusionCalculator.CalculateAcadExtrusion(mtextPoint, mtextExt); |
217 |
((DwgMText)dwgObject).setInsertionPoint(mtextPoint); |
218 |
} else if (dwgObject instanceof DwgPoint) { |
219 |
double[] point = ((DwgPoint)dwgObject).getPoint(); |
220 |
double[] pointExt = ((DwgPoint)dwgObject).getExtrusion(); |
221 |
point = AcadExtrusionCalculator.CalculateAcadExtrusion(point, pointExt); |
222 |
((DwgPoint)dwgObject).setPoint(point); |
223 |
} else if (dwgObject instanceof DwgSolid) { |
224 |
double[] corner1 = ((DwgSolid)dwgObject).getCorner1(); |
225 |
double[] corner2 = ((DwgSolid)dwgObject).getCorner2(); |
226 |
double[] corner3 = ((DwgSolid)dwgObject).getCorner3(); |
227 |
double[] corner4 = ((DwgSolid)dwgObject).getCorner4(); |
228 |
double[] solidExt = ((DwgSolid)dwgObject).getExtrusion(); |
229 |
corner1 = AcadExtrusionCalculator.CalculateAcadExtrusion(corner1, solidExt); |
230 |
((DwgSolid)dwgObject).setCorner1(corner1); |
231 |
((DwgSolid)dwgObject).setCorner2(corner2); |
232 |
((DwgSolid)dwgObject).setCorner3(corner3); |
233 |
((DwgSolid)dwgObject).setCorner4(corner4); |
234 |
} else if (dwgObject instanceof DwgSpline) { |
235 |
// DwgSpline hasn't Extrusion
|
236 |
} else if (dwgObject instanceof DwgText) { |
237 |
Point2D tpoint = ((DwgText)dwgObject).getInsertionPoint();
|
238 |
double elev = ((DwgText)dwgObject).getElevation();
|
239 |
double[] textPoint = new double[]{tpoint.getX(), tpoint.getY(), elev}; |
240 |
double[] textExt = ((DwgText)dwgObject).getExtrusion(); |
241 |
textPoint = AcadExtrusionCalculator.CalculateAcadExtrusion(textPoint, textExt); |
242 |
((DwgText)dwgObject).setInsertionPoint(new Point2D.Double(textPoint[0], textPoint[1])); |
243 |
((DwgText)dwgObject).setElevation(elev); |
244 |
} else if (dwgObject instanceof DwgPolyline2D && ((DwgPolyline2D)dwgObject).getPts()!=null) { |
245 |
Point2D[] vertices = ((DwgPolyline2D)dwgObject).getPts(); |
246 |
double[] polyline2DExt = ((DwgPolyline2D)dwgObject).getExtrusion(); |
247 |
double elev = ((DwgPolyline2D)dwgObject).getElevation();
|
248 |
double[][] polylinePoints3D = new double[vertices.length][3]; |
249 |
for (int j=0;j<vertices.length;j++) { |
250 |
polylinePoints3D[j][0] = vertices[j].getX();
|
251 |
polylinePoints3D[j][1] = vertices[j].getY();
|
252 |
polylinePoints3D[j][2] = elev;
|
253 |
polylinePoints3D[j] = AcadExtrusionCalculator.CalculateAcadExtrusion(polylinePoints3D[j], polyline2DExt); |
254 |
} |
255 |
((DwgPolyline2D)dwgObject).setElevation(elev); |
256 |
for (int j=0;j<vertices.length;j++) { |
257 |
vertices[j] = new Point2D.Double(polylinePoints3D[j][0], polylinePoints3D[j][1]); |
258 |
} |
259 |
((DwgPolyline2D)dwgObject).setPts(vertices); |
260 |
} else if (dwgObject instanceof DwgPolyline3D) { |
261 |
// DwgPolyline3D hasn't Extrusion
|
262 |
} else if (dwgObject instanceof DwgVertex2D) { |
263 |
// DwgVertex2D hasn't Extrusion
|
264 |
} else if (dwgObject instanceof DwgVertex3D) { |
265 |
// DwgVertex3D hasn't Extrusion
|
266 |
} else {
|
267 |
//
|
268 |
} |
269 |
} |
270 |
} |
271 |
|
272 |
/**
|
273 |
* Configure the geometry of the polylines in a DWG file from the vertex list in
|
274 |
* this DWG file. This geometry is given by an array of Points.
|
275 |
* Besides, manage closed polylines and polylines with bulges in a GIS Data model.
|
276 |
* It means that the arcs of the polylines will be done through a set of points and
|
277 |
* a distance between these points.
|
278 |
*/
|
279 |
public void calculateGisModelDwgPolylines() { |
280 |
for (int i=0;i<dwgObjects.size();i++) { |
281 |
DwgObject pol = (DwgObject)dwgObjects.get(i); |
282 |
if (pol instanceof DwgPolyline2D) { |
283 |
int flags = ((DwgPolyline2D)pol).getFlags();
|
284 |
int firstHandle = ((DwgPolyline2D)pol).getFirstVertexHandle();
|
285 |
int lastHandle = ((DwgPolyline2D)pol).getLastVertexHandle();
|
286 |
Vector pts = new Vector(); |
287 |
Vector bulges = new Vector(); |
288 |
double[] pt = new double[3]; |
289 |
for (int j=0;j<dwgObjects.size();j++) { |
290 |
DwgObject firstVertex = (DwgObject)dwgObjects.get(j); |
291 |
if (firstVertex instanceof DwgVertex2D) { |
292 |
int vertexHandle = firstVertex.getHandle();
|
293 |
if (vertexHandle==firstHandle) {
|
294 |
int k=0; |
295 |
while (true) { |
296 |
DwgObject vertex = (DwgObject)dwgObjects.get(j+k); |
297 |
int vHandle = vertex.getHandle();
|
298 |
if (vertex instanceof DwgVertex2D) { |
299 |
pt = ((DwgVertex2D)vertex).getPoint(); |
300 |
pts.add(new Point2D.Double(pt[0], pt[1])); |
301 |
double bulge = ((DwgVertex2D)vertex).getBulge();
|
302 |
bulges.add(new Double(bulge)); |
303 |
k++; |
304 |
if (vHandle==lastHandle && vertex instanceof DwgVertex2D) { |
305 |
break;
|
306 |
} |
307 |
} else if (vertex instanceof DwgSeqend) { |
308 |
break;
|
309 |
} |
310 |
} |
311 |
} |
312 |
} |
313 |
} |
314 |
if (pts.size()>0) { |
315 |
Point2D[] newPts = new Point2D[pts.size()]; |
316 |
if ((flags & 0x1)==0x1) { |
317 |
newPts = new Point2D[pts.size()+1]; |
318 |
for (int j=0;j<pts.size();j++) { |
319 |
newPts[j] = (Point2D)pts.get(j);
|
320 |
} |
321 |
newPts[pts.size()] = (Point2D)pts.get(0); |
322 |
bulges.add(new Double(0)); |
323 |
} else {
|
324 |
for (int j=0;j<pts.size();j++) { |
325 |
newPts[j] = (Point2D)pts.get(j);
|
326 |
} |
327 |
} |
328 |
double[] bs = new double[bulges.size()]; |
329 |
for (int j=0;j<bulges.size();j++) { |
330 |
bs[j] = ((Double)bulges.get(j)).doubleValue();
|
331 |
} |
332 |
((DwgPolyline2D)pol).setBulges(bs); |
333 |
Point2D[] points = GisModelCurveCalculator.calculateGisModelBulge(newPts, bs); |
334 |
((DwgPolyline2D)pol).setPts(points); |
335 |
} else {
|
336 |
System.out.println("Encontrada polil?nea sin puntos ..."); |
337 |
// TODO: No se debe mandar nunca una polil?nea sin puntos, si esto
|
338 |
// ocurre es porque existe un error que hay que corregir ...
|
339 |
} |
340 |
} else if (pol instanceof DwgPolyline3D) { |
341 |
int closedFlags = ((DwgPolyline3D)pol).getClosedFlags();
|
342 |
int firstHandle = ((DwgPolyline3D)pol).getFirstVertexHandle();
|
343 |
int lastHandle = ((DwgPolyline3D)pol).getLastVertexHandle();
|
344 |
Vector pts = new Vector(); |
345 |
double[] pt = new double[3]; |
346 |
for (int j=0;j<dwgObjects.size();j++) { |
347 |
DwgObject firstVertex = (DwgObject)dwgObjects.get(j); |
348 |
if (firstVertex instanceof DwgVertex3D) { |
349 |
int vertexHandle = firstVertex.getHandle();
|
350 |
if (vertexHandle==firstHandle) {
|
351 |
int k=0; |
352 |
while (true) { |
353 |
DwgObject vertex = (DwgObject)dwgObjects.get(j+k); |
354 |
int vHandle = vertex.getHandle();
|
355 |
if (vertex instanceof DwgVertex3D) { |
356 |
pt = ((DwgVertex3D)vertex).getPoint(); |
357 |
pts.add(new double[]{pt[0], pt[1], pt[2]}); |
358 |
k++; |
359 |
if (vHandle==lastHandle && vertex instanceof DwgVertex3D) { |
360 |
break;
|
361 |
} |
362 |
} else if (vertex instanceof DwgSeqend) { |
363 |
break;
|
364 |
} |
365 |
} |
366 |
} |
367 |
} |
368 |
} |
369 |
if (pts.size()>0) { |
370 |
double[][] newPts = new double[pts.size()][3]; |
371 |
if ((closedFlags & 0x1)==0x1) { |
372 |
newPts = new double[pts.size()+1][3]; |
373 |
for (int j=0;j<pts.size();j++) { |
374 |
newPts[j][0] = ((double[])pts.get(j))[0]; |
375 |
newPts[j][1] = ((double[])pts.get(j))[1]; |
376 |
newPts[j][2] = ((double[])pts.get(j))[2]; |
377 |
} |
378 |
newPts[pts.size()][0] = ((double[])pts.get(0))[0]; |
379 |
newPts[pts.size()][1] = ((double[])pts.get(0))[1]; |
380 |
newPts[pts.size()][2] = ((double[])pts.get(0))[2]; |
381 |
} else {
|
382 |
for (int j=0;j<pts.size();j++) { |
383 |
newPts[j][0] = ((double[])pts.get(j))[0]; |
384 |
newPts[j][1] = ((double[])pts.get(j))[1]; |
385 |
newPts[j][2] = ((double[])pts.get(j))[2]; |
386 |
} |
387 |
} |
388 |
((DwgPolyline3D)pol).setPts(newPts); |
389 |
} else {
|
390 |
System.out.println("Encontrada polil?nea sin puntos ..."); |
391 |
// TODO: No se debe mandar nunca una polil?nea sin puntos, si esto
|
392 |
// ocurre es porque existe un error que hay que corregir ...
|
393 |
} |
394 |
} else if (pol instanceof DwgLwPolyline && ((DwgLwPolyline)pol).getVertices()!=null) { |
395 |
int flags = ((DwgLwPolyline)pol).getFlag();
|
396 |
Point2D[] pts = ((DwgLwPolyline)pol).getVertices(); |
397 |
double[] bulges = ((DwgLwPolyline)pol).getBulges(); |
398 |
Point2D[] newPts = new Point2D[pts.length]; |
399 |
double[] newBulges = new double[bulges.length]; |
400 |
// TODO: Aqu? pueden existir casos no contemplados ...
|
401 |
System.out.println("flags = " + flags); |
402 |
if (flags==512 || flags==776 || flags==768) { |
403 |
newPts = new Point2D[pts.length+1]; |
404 |
newBulges = new double[bulges.length+1]; |
405 |
for (int j=0;j<pts.length;j++) { |
406 |
newPts[j] = (Point2D)pts[j];
|
407 |
} |
408 |
newPts[pts.length] = (Point2D)pts[0]; |
409 |
newBulges[pts.length] = 0;
|
410 |
} else {
|
411 |
for (int j=0;j<pts.length;j++) { |
412 |
newPts[j] = (Point2D)pts[j];
|
413 |
} |
414 |
} |
415 |
if (pts.length>0) { |
416 |
((DwgLwPolyline)pol).setBulges(newBulges); |
417 |
Point2D[] points = GisModelCurveCalculator.calculateGisModelBulge(newPts, newBulges); |
418 |
((DwgLwPolyline)pol).setVertices(points); |
419 |
} else {
|
420 |
System.out.println("Encontrada polil?nea sin puntos ..."); |
421 |
// TODO: No se debe mandar nunca una polil?nea sin puntos, si esto
|
422 |
// ocurre es porque existe un error que hay que corregir ...
|
423 |
} |
424 |
} |
425 |
} |
426 |
} |
427 |
|
428 |
/**
|
429 |
* Configure the geometry of the polylines in a DWG file from the vertex list in
|
430 |
* this DWG file. This geometry is given by an array of Points
|
431 |
* Besides, manage closed polylines and polylines with bulges in a GIS Data model.
|
432 |
* It means that the arcs of the polylines will be done through a curvature
|
433 |
* parameter called bulge associated with the points of the polyline.
|
434 |
*/
|
435 |
public void calculateCadModelDwgPolylines() { |
436 |
for (int i=0;i<dwgObjects.size();i++) { |
437 |
DwgObject pol = (DwgObject)dwgObjects.get(i); |
438 |
if (pol instanceof DwgPolyline2D) { |
439 |
int flags = ((DwgPolyline2D)pol).getFlags();
|
440 |
int firstHandle = ((DwgPolyline2D)pol).getFirstVertexHandle();
|
441 |
int lastHandle = ((DwgPolyline2D)pol).getLastVertexHandle();
|
442 |
Vector pts = new Vector(); |
443 |
Vector bulges = new Vector(); |
444 |
double[] pt = new double[3]; |
445 |
for (int j=0;j<dwgObjects.size();j++) { |
446 |
DwgObject firstVertex = (DwgObject)dwgObjects.get(j); |
447 |
if (firstVertex instanceof DwgVertex2D) { |
448 |
int vertexHandle = firstVertex.getHandle();
|
449 |
if (vertexHandle==firstHandle) {
|
450 |
int k=0; |
451 |
while (true) { |
452 |
DwgObject vertex = (DwgObject)dwgObjects.get(j+k); |
453 |
int vHandle = vertex.getHandle();
|
454 |
if (vertex instanceof DwgVertex2D) { |
455 |
pt = ((DwgVertex2D)vertex).getPoint(); |
456 |
pts.add(new Point2D.Double(pt[0], pt[1])); |
457 |
double bulge = ((DwgVertex2D)vertex).getBulge();
|
458 |
bulges.add(new Double(bulge)); |
459 |
k++; |
460 |
if (vHandle==lastHandle && vertex instanceof DwgVertex2D) { |
461 |
break;
|
462 |
} |
463 |
} else if (vertex instanceof DwgSeqend) { |
464 |
break;
|
465 |
} |
466 |
} |
467 |
} |
468 |
} |
469 |
} |
470 |
if (pts.size()>0) { |
471 |
/*Point2D[] newPts = new Point2D[pts.size()];
|
472 |
if ((flags & 0x1)==0x1) {
|
473 |
newPts = new Point2D[pts.size()+1];
|
474 |
for (int j=0;j<pts.size();j++) {
|
475 |
newPts[j] = (Point2D)pts.get(j);
|
476 |
}
|
477 |
newPts[pts.size()] = (Point2D)pts.get(0);
|
478 |
bulges.add(new Double(0));
|
479 |
} else {
|
480 |
for (int j=0;j<pts.size();j++) {
|
481 |
newPts[j] = (Point2D)pts.get(j);
|
482 |
}
|
483 |
}*/
|
484 |
double[] bs = new double[bulges.size()]; |
485 |
for (int j=0;j<bulges.size();j++) { |
486 |
bs[j] = ((Double)bulges.get(j)).doubleValue();
|
487 |
} |
488 |
((DwgPolyline2D)pol).setBulges(bs); |
489 |
//Point2D[] points = GisModelCurveCalculator.calculateGisModelBulge(newPts, bs);
|
490 |
Point2D[] points = new Point2D[pts.size()]; |
491 |
for (int j=0;j<pts.size();j++) { |
492 |
points[j] = (Point2D)pts.get(j);
|
493 |
} |
494 |
((DwgPolyline2D)pol).setPts(points); |
495 |
} else {
|
496 |
System.out.println("Encontrada polil?nea sin puntos ..."); |
497 |
// TODO: No se debe mandar nunca una polil?nea sin puntos, si esto
|
498 |
// ocurre es porque existe un error que hay que corregir ...
|
499 |
} |
500 |
} else if (pol instanceof DwgPolyline3D) { |
501 |
} else if (pol instanceof DwgLwPolyline && ((DwgLwPolyline)pol).getVertices()!=null) { |
502 |
} |
503 |
} |
504 |
} |
505 |
|
506 |
/**
|
507 |
* Modify the geometry of the objects contained in the blocks of a DWG file and
|
508 |
* add these objects to the DWG object list.
|
509 |
*/
|
510 |
public void blockManagement() { |
511 |
Vector dwgObjectsWithoutBlocks = new Vector(); |
512 |
boolean addingToBlock = false; |
513 |
for (int i=0;i<dwgObjects.size();i++) { |
514 |
DwgObject entity = (DwgObject)dwgObjects.get(i); |
515 |
if (entity instanceof DwgArc && !addingToBlock) { |
516 |
dwgObjectsWithoutBlocks.add(entity); |
517 |
} else if (entity instanceof DwgEllipse && !addingToBlock) { |
518 |
dwgObjectsWithoutBlocks.add(entity); |
519 |
} else if (entity instanceof DwgCircle && !addingToBlock) { |
520 |
dwgObjectsWithoutBlocks.add(entity); |
521 |
} else if (entity instanceof DwgPolyline2D && !addingToBlock) { |
522 |
dwgObjectsWithoutBlocks.add(entity); |
523 |
} else if (entity instanceof DwgPolyline3D && !addingToBlock) { |
524 |
dwgObjectsWithoutBlocks.add(entity); |
525 |
} else if (entity instanceof DwgLwPolyline && !addingToBlock) { |
526 |
dwgObjectsWithoutBlocks.add(entity); |
527 |
} else if (entity instanceof DwgSolid && !addingToBlock) { |
528 |
dwgObjectsWithoutBlocks.add(entity); |
529 |
} else if (entity instanceof DwgLine && !addingToBlock) { |
530 |
dwgObjectsWithoutBlocks.add(entity); |
531 |
} else if (entity instanceof DwgPoint && !addingToBlock) { |
532 |
dwgObjectsWithoutBlocks.add(entity); |
533 |
} else if (entity instanceof DwgMText && !addingToBlock) { |
534 |
dwgObjectsWithoutBlocks.add(entity); |
535 |
} else if (entity instanceof DwgText && !addingToBlock) { |
536 |
dwgObjectsWithoutBlocks.add(entity); |
537 |
} else if (entity instanceof DwgAttrib && !addingToBlock) { |
538 |
dwgObjectsWithoutBlocks.add(entity); |
539 |
} else if (entity instanceof DwgAttdef && !addingToBlock) { |
540 |
dwgObjectsWithoutBlocks.add(entity); |
541 |
} else if (entity instanceof DwgBlock) { |
542 |
addingToBlock = true;
|
543 |
} else if (entity instanceof DwgEndblk) { |
544 |
addingToBlock = false;
|
545 |
} else if (entity instanceof DwgBlockHeader) { |
546 |
addingToBlock = true;
|
547 |
} else if (entity instanceof DwgInsert && !addingToBlock) { |
548 |
double[] p = ((DwgInsert)entity).getInsertionPoint(); |
549 |
Point2D point = new Point2D.Double(p[0], p[1]); |
550 |
double[] scale = ((DwgInsert)entity).getScale(); |
551 |
double rot = ((DwgInsert)entity).getRotation();
|
552 |
int blockHandle = ((DwgInsert)entity).getBlockHeaderHandle();
|
553 |
manageInsert(point, scale, rot, blockHandle, i, dwgObjectsWithoutBlocks); |
554 |
} else {
|
555 |
//System.out.println("Detectado dwgObject pendiente de implementar");
|
556 |
} |
557 |
} |
558 |
dwgObjects = dwgObjectsWithoutBlocks; |
559 |
} |
560 |
|
561 |
/**
|
562 |
* Manages an INSERT of a DWG file. This object is the insertion point of a DWG
|
563 |
* block. It has the next parameters:
|
564 |
* @param insPoint, coordinates of the insertion point.
|
565 |
* @param scale, scale of the elements of the block that will be inserted.
|
566 |
* @param rot, rotation angle of the elements of the block.
|
567 |
* @param bHandle, offset for the coordinates of the elements of the block.
|
568 |
* @param id, count that serves as a id.
|
569 |
* @param dwgObjectsWithoutBlocks, a object list with the elements extracted from
|
570 |
* the blocks.
|
571 |
*/
|
572 |
private void manageInsert(Point2D insPoint, double[] scale, double rot, int bHandle, int id, Vector dwgObjectsWithoutBlocks) { |
573 |
for (int i=0;i<dwgObjects.size();i++) { |
574 |
DwgObject obj = (DwgObject)dwgObjects.get(i); |
575 |
if (obj instanceof DwgBlockHeader) { |
576 |
int objHandle = ((DwgBlockHeader)obj).getHandle();
|
577 |
if (objHandle==bHandle) {
|
578 |
//System.out.println("Encontrado DwgBlockHeader con handle = " + bHandle);
|
579 |
double[] bPoint = ((DwgBlockHeader)obj).getBasePoint(); |
580 |
String bname = ((DwgBlockHeader)obj).getName();
|
581 |
//System.out.println("Nombre del bloque = " + bname);
|
582 |
if (!bname.startsWith("*")) { |
583 |
int firstObjectHandle = ((DwgBlockHeader)obj).getFirstEntityHandle();
|
584 |
//System.out.println("firstObjectHandle = " + firstObjectHandle);
|
585 |
int lastObjectHandle = ((DwgBlockHeader)obj).getLastEntityHandle();
|
586 |
//System.out.println("lastObjectHandle = " + lastObjectHandle);
|
587 |
DwgBlock block = null;
|
588 |
for (int j=0;j<dwgObjects.size();j++) { |
589 |
DwgObject ent = (DwgObject)dwgObjects.get(j); |
590 |
if (ent instanceof DwgBlock) { |
591 |
String name = ((DwgBlock)ent).getName();
|
592 |
if (bname.equals(name)) {
|
593 |
block = (DwgBlock)ent; |
594 |
//System.out.println("Encontrado DwgBlock con bname = " + bname);
|
595 |
break;
|
596 |
} |
597 |
} |
598 |
} |
599 |
for (int j=0;j<dwgObjects.size();j++) { |
600 |
DwgObject fObj = (DwgObject)dwgObjects.get(j); |
601 |
if (fObj!=null) { |
602 |
int fObjHandle = fObj.getHandle();
|
603 |
if (fObjHandle==firstObjectHandle) {
|
604 |
int k=0; |
605 |
while (true) { |
606 |
//System.out.println("Encontrado elemento " + k + " del bloque");
|
607 |
DwgObject iObj = (DwgObject)dwgObjects.get(j+k); |
608 |
int iObjHandle = iObj.getHandle();
|
609 |
System.out.println("iObj.getType() = " + iObj.getType()); |
610 |
System.out.println("insPoint.getX() = " + insPoint.getX()); |
611 |
System.out.println("insPoint.getY() = " + insPoint.getY()); |
612 |
System.out.println("rot = " + rot); |
613 |
manageBlockEntity(iObj, bPoint, insPoint, scale, rot, id, dwgObjectsWithoutBlocks); |
614 |
k++; |
615 |
if (iObjHandle==lastObjectHandle) break; |
616 |
} |
617 |
} |
618 |
} |
619 |
} |
620 |
break;
|
621 |
} |
622 |
} |
623 |
} |
624 |
} |
625 |
} |
626 |
|
627 |
/**
|
628 |
* Changes the location of an object extracted from a block. This location will be
|
629 |
* obtained through the insertion parameters from the block and the corresponding
|
630 |
* insert.
|
631 |
* @param entity, the entity extracted from the block.
|
632 |
* @param bPoint, offset for the coordinates of the entity.
|
633 |
* @param insPoint, coordinates of the insertion point for the entity.
|
634 |
* @param scale, scale for the entity.
|
635 |
* @param rot, rotation angle for the entity.
|
636 |
* @param id, a count as a id.
|
637 |
* @param dwgObjectsWithoutBlocks, a object list with the elements extracted from
|
638 |
* the blocks.
|
639 |
*/
|
640 |
private void manageBlockEntity(DwgObject entity, double[] bPoint, Point2D insPoint, double[] scale, double rot, int id, Vector dwgObjectsWithoutBlocks) { |
641 |
if (entity instanceof DwgArc) { |
642 |
//System.out.println("Encuentra un arco dentro de un bloque ...");
|
643 |
DwgArc transformedEntity = new DwgArc();
|
644 |
double[] center = ((DwgArc)entity).getCenter(); |
645 |
Point2D pointAux = new Point2D.Double(center[0] - bPoint[0], center[1] - bPoint[1]); |
646 |
double laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot)); |
647 |
double laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot)); |
648 |
double laZ = center[2] * scale[2]; |
649 |
double[] transformedCenter = new double[]{laX, laY, laZ}; |
650 |
double radius = ((DwgArc)entity).getRadius();
|
651 |
System.out.println("radius = " + radius); |
652 |
System.out.println("scale[0] = " + scale[0]); |
653 |
System.out.println("scale[1] = " + scale[1]); |
654 |
System.out.println("rot = " + rot); |
655 |
double transformedRadius = radius * scale[0]; |
656 |
double initAngle = ((DwgArc)entity).getInitAngle();
|
657 |
double endAngle = ((DwgArc)entity).getEndAngle();
|
658 |
System.out.println("initAngle = " + initAngle); |
659 |
System.out.println("endAngle = " + endAngle); |
660 |
System.out.println("rot = " + rot); |
661 |
double transformedInitAngle = initAngle + rot;
|
662 |
if (transformedInitAngle<0) { |
663 |
transformedInitAngle = transformedInitAngle + (2*Math.PI); |
664 |
} else if (transformedInitAngle>(2*Math.PI)) { |
665 |
transformedInitAngle = transformedInitAngle - (2*Math.PI); |
666 |
} |
667 |
double transformedEndAngle = endAngle + rot;
|
668 |
if (transformedEndAngle<0) { |
669 |
transformedEndAngle = transformedEndAngle + (2*Math.PI); |
670 |
} else if (transformedEndAngle>(2*Math.PI)) { |
671 |
transformedEndAngle = transformedEndAngle - (2*Math.PI); |
672 |
} |
673 |
transformedEntity = (DwgArc)((DwgArc)entity).clone(); |
674 |
transformedEntity.setCenter(transformedCenter); |
675 |
transformedEntity.setRadius(transformedRadius); |
676 |
transformedEntity.setInitAngle(transformedInitAngle); |
677 |
transformedEntity.setEndAngle(transformedEndAngle); |
678 |
dwgObjectsWithoutBlocks.add(transformedEntity); |
679 |
} else if (entity instanceof DwgCircle) { |
680 |
//System.out.println("Encuentra un c?rculo dentro de un bloque ...");
|
681 |
DwgCircle transformedEntity = new DwgCircle();
|
682 |
double[] center = ((DwgCircle)entity).getCenter(); |
683 |
Point2D pointAux = new Point2D.Double(center[0] - bPoint[0], center[1] - bPoint[1]); |
684 |
double laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot)); |
685 |
double laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot)); |
686 |
double laZ = center[2] * scale[2]; |
687 |
double[] transformedCenter = new double[]{laX, laY, laZ}; |
688 |
double radius = ((DwgCircle)entity).getRadius();
|
689 |
double transformedRadius = radius * scale[0]; |
690 |
transformedEntity = (DwgCircle)((DwgCircle)entity).clone(); |
691 |
transformedEntity.setCenter(transformedCenter); |
692 |
transformedEntity.setRadius(transformedRadius); |
693 |
dwgObjectsWithoutBlocks.add(transformedEntity); |
694 |
} else if (entity instanceof DwgEllipse) { |
695 |
DwgEllipse transformedEntity = new DwgEllipse();
|
696 |
double[] center = ((DwgEllipse)entity).getCenter(); |
697 |
Point2D pointAux = new Point2D.Double(center[0] - bPoint[0], center[1] - bPoint[1]); |
698 |
double laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot)); |
699 |
double laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot)); |
700 |
double laZ = center[2] * scale[2]; |
701 |
double[] transformedCenter = new double[]{laX, laY, laZ}; |
702 |
double[] majorAxisVector = ((DwgEllipse)entity).getMajorAxisVector(); |
703 |
double[] transformedMajorAxisVector = new double[]{majorAxisVector[0] * scale[0], majorAxisVector[1] * scale[1], majorAxisVector[2] * scale[2]}; |
704 |
//TODO: Rotar un ?ngulo rot el vector majorAxisVector fijado en
|
705 |
// center.
|
706 |
double axisRatio = ((DwgEllipse)entity).getAxisRatio();
|
707 |
double transformedAxisRatio = axisRatio;
|
708 |
double initAngle = ((DwgEllipse)entity).getInitAngle();
|
709 |
double endAngle = ((DwgEllipse)entity).getEndAngle();
|
710 |
double transformedInitAngle = initAngle + rot;
|
711 |
if (transformedInitAngle<0) { |
712 |
transformedInitAngle = transformedInitAngle + (2*Math.PI); |
713 |
} else if (transformedInitAngle>(2*Math.PI)) { |
714 |
transformedInitAngle = transformedInitAngle - (2*Math.PI); |
715 |
} |
716 |
double transformedEndAngle = endAngle + rot;
|
717 |
if (transformedEndAngle<0) { |
718 |
transformedEndAngle = transformedEndAngle + (2*Math.PI); |
719 |
} else if (transformedEndAngle>(2*Math.PI)) { |
720 |
transformedEndAngle = transformedEndAngle - (2*Math.PI); |
721 |
} |
722 |
transformedEntity = (DwgEllipse)((DwgEllipse)entity).clone(); |
723 |
transformedEntity.setCenter(transformedCenter); |
724 |
transformedEntity.setMajorAxisVector(transformedMajorAxisVector); |
725 |
transformedEntity.setAxisRatio(transformedAxisRatio); |
726 |
transformedEntity.setInitAngle(transformedInitAngle); |
727 |
transformedEntity.setEndAngle(transformedEndAngle); |
728 |
dwgObjectsWithoutBlocks.add(transformedEntity); |
729 |
} else if (entity instanceof DwgLine) { |
730 |
//System.out.println("Encuentra una l?nea dentro de un bloque ...");
|
731 |
DwgLine transformedEntity = new DwgLine();
|
732 |
double[] p1 = ((DwgLine)entity).getP1(); |
733 |
double[] p2 = ((DwgLine)entity).getP2(); |
734 |
Point2D pointAux = new Point2D.Double(p1[0] - bPoint[0], p1[1] - bPoint[1]); |
735 |
double laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot)); |
736 |
double laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot)); |
737 |
double[] transformedP1 = null; |
738 |
if (((DwgLine)entity).isZflag()) {
|
739 |
double laZ = p1[2] * scale[2]; |
740 |
transformedP1 = new double[]{laX, laY, laZ}; |
741 |
} else {
|
742 |
transformedP1 = new double[]{laX, laY}; |
743 |
} |
744 |
//double[] transformedP1 = new double[]{laX, laY};
|
745 |
pointAux = new Point2D.Double(p2[0] - bPoint[0], p2[1] - bPoint[1]); |
746 |
laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot)); |
747 |
laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot)); |
748 |
double[] transformedP2 = null; |
749 |
if (((DwgLine)entity).isZflag()) {
|
750 |
double laZ = p2[2] * scale[2]; |
751 |
transformedP2 = new double[]{laX, laY, laZ}; |
752 |
} else {
|
753 |
transformedP2 = new double[]{laX, laY}; |
754 |
} |
755 |
//double[] transformedP2 = new double[]{laX, laY};
|
756 |
transformedEntity = (DwgLine)((DwgLine)entity).clone(); |
757 |
transformedEntity.setP1(transformedP1); |
758 |
transformedEntity.setP2(transformedP2); |
759 |
dwgObjectsWithoutBlocks.add(transformedEntity); |
760 |
} else if (entity instanceof DwgLwPolyline) { |
761 |
//System.out.println("Encuentra una DwgLwPolyline dentro de un bloque ...");
|
762 |
DwgLwPolyline transformedEntity = new DwgLwPolyline();
|
763 |
Point2D[] vertices = ((DwgLwPolyline)entity).getVertices(); |
764 |
if (vertices!=null) { |
765 |
Point2D[] transformedVertices = new Point2D[vertices.length]; |
766 |
for (int i=0;i<vertices.length;i++) { |
767 |
Point2D pointAux = new Point2D.Double(vertices[i].getX() - bPoint[0], vertices[i].getY() - bPoint[1]); |
768 |
double laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot)); |
769 |
double laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot)); |
770 |
transformedVertices[i] = new Point2D.Double(laX, laY); |
771 |
} |
772 |
transformedEntity = (DwgLwPolyline)((DwgLwPolyline)entity).clone(); |
773 |
transformedEntity.setVertices(transformedVertices); |
774 |
transformedEntity.setElevation(((DwgLwPolyline)entity).getElevation() * scale[2]);
|
775 |
dwgObjectsWithoutBlocks.add(transformedEntity); |
776 |
} |
777 |
} else if (entity instanceof DwgMText) { |
778 |
|
779 |
} else if (entity instanceof DwgPoint) { |
780 |
|
781 |
} else if (entity instanceof DwgPolyline2D) { |
782 |
//System.out.println("Encuentra una polil?nea dentro de un bloque ...");
|
783 |
DwgPolyline2D transformedEntity = new DwgPolyline2D();
|
784 |
Point2D[] vertices = ((DwgPolyline2D)entity).getPts(); |
785 |
if (vertices!=null) { |
786 |
Point2D[] transformedVertices = new Point2D[vertices.length]; |
787 |
for (int i=0;i<vertices.length;i++) { |
788 |
Point2D pointAux = new Point2D.Double(vertices[i].getX() - bPoint[0], vertices[i].getY() - bPoint[1]); |
789 |
double laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot)); |
790 |
double laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot)); |
791 |
transformedVertices[i] = new Point2D.Double(laX, laY); |
792 |
} |
793 |
transformedEntity = (DwgPolyline2D)((DwgPolyline2D)entity).clone(); |
794 |
transformedEntity.setPts(transformedVertices); |
795 |
transformedEntity.setElevation(((DwgPolyline2D)entity).getElevation() * scale[2]);
|
796 |
dwgObjectsWithoutBlocks.add(transformedEntity); |
797 |
} |
798 |
} else if (entity instanceof DwgPolyline3D) { |
799 |
|
800 |
} else if (entity instanceof DwgSolid) { |
801 |
DwgSolid transformedEntity = new DwgSolid();
|
802 |
double[] corner1 = ((DwgSolid)entity).getCorner1(); |
803 |
double[] corner2 = ((DwgSolid)entity).getCorner2(); |
804 |
double[] corner3 = ((DwgSolid)entity).getCorner3(); |
805 |
double[] corner4 = ((DwgSolid)entity).getCorner4(); |
806 |
Point2D pointAux = new Point2D.Double(corner1[0] - bPoint[0], corner1[1] - bPoint[1]); |
807 |
double laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot)); |
808 |
double laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot)); |
809 |
double[] transformedP1 = new double[]{laX, laY}; |
810 |
pointAux = new Point2D.Double(corner2[0] - bPoint[0], corner2[1] - bPoint[1]); |
811 |
laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot)); |
812 |
laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot)); |
813 |
double[] transformedP2 = new double[]{laX, laY}; |
814 |
pointAux = new Point2D.Double(corner3[0] - bPoint[0], corner3[1] - bPoint[1]); |
815 |
laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot)); |
816 |
laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot)); |
817 |
double[] transformedP3 = new double[]{laX, laY}; |
818 |
pointAux = new Point2D.Double(corner4[0] - bPoint[0], corner4[1] - bPoint[1]); |
819 |
laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot)); |
820 |
laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot)); |
821 |
double[] transformedP4 = new double[]{laX, laY}; |
822 |
transformedEntity = (DwgSolid)((DwgSolid)entity).clone(); |
823 |
transformedEntity.setCorner1(transformedP1); |
824 |
transformedEntity.setCorner2(transformedP2); |
825 |
transformedEntity.setCorner3(transformedP3); |
826 |
transformedEntity.setCorner4(transformedP4); |
827 |
transformedEntity.setElevation(((DwgSolid)entity).getElevation() * scale[2]);
|
828 |
dwgObjectsWithoutBlocks.add(transformedEntity); |
829 |
} else if (entity instanceof DwgSpline) { |
830 |
|
831 |
} else if (entity instanceof DwgText) { |
832 |
|
833 |
} else if (entity instanceof DwgInsert) { |
834 |
//System.out.println("Encuentra un insert dentro de un bloque ...");
|
835 |
DwgInsert transformedEntity = new DwgInsert();
|
836 |
double[] p = ((DwgInsert)entity).getInsertionPoint(); |
837 |
Point2D point = new Point2D.Double(p[0], p[1]); |
838 |
double[] newScale = ((DwgInsert)entity).getScale(); |
839 |
double newRot = ((DwgInsert)entity).getRotation();
|
840 |
int newBlockHandle = ((DwgInsert)entity).getBlockHeaderHandle();
|
841 |
Point2D pointAux = new Point2D.Double(point.getX() - bPoint[0], point.getY() - bPoint[1]); |
842 |
double laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot)); |
843 |
double laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot)); |
844 |
double laZ = p[2] * scale[2]; |
845 |
Point2D newInsPoint = new Point2D.Double(laX, laY); |
846 |
newScale = new double[]{scale[0]*newScale[0], scale[1]*newScale[1], scale[2]*newScale[2]}; |
847 |
newRot = newRot + rot; |
848 |
if (newRot<0) { |
849 |
newRot = newRot + (2*Math.PI); |
850 |
} else if (newRot>(2*Math.PI)) { |
851 |
newRot = newRot - (2*Math.PI); |
852 |
} |
853 |
manageInsert(newInsPoint, newScale, newRot, newBlockHandle, id, dwgObjectsWithoutBlocks); |
854 |
} |
855 |
} |
856 |
|
857 |
/**
|
858 |
* Initialize a new Vector that contains the DWG file layers. Each layer have three
|
859 |
* parameters. These parameters are handle, name and color
|
860 |
*/
|
861 |
public void initializeLayerTable() { |
862 |
layerTable = new Vector(); |
863 |
for (int i=0;i<dwgObjects.size();i++) { |
864 |
DwgObject obj = (DwgObject)dwgObjects.get(i); |
865 |
if (obj instanceof DwgLayer) { |
866 |
Vector layerTableRecord = new Vector(); |
867 |
layerTableRecord.add(new Integer(obj.getHandle())); |
868 |
layerTableRecord.add(((DwgLayer)obj).getName()); |
869 |
layerTableRecord.add(new Integer(((DwgLayer)obj).getColor())); |
870 |
layerTable.add(layerTableRecord); |
871 |
} |
872 |
} |
873 |
} |
874 |
|
875 |
/**
|
876 |
* Returns the name of the layer of a DWG object
|
877 |
*
|
878 |
* @param entity DWG object which we want to know its layer name
|
879 |
* @return String Layer name of the DWG object
|
880 |
*/
|
881 |
// TODO: Gesti?n de capas pendiente ...
|
882 |
public String getLayerName(DwgObject entity) { |
883 |
String layerName = ""; |
884 |
int layer = entity.getLayerHandle();
|
885 |
for (int j=0;j<layerTable.size();j++) { |
886 |
Vector layerTableRecord = (Vector)layerTable.get(j); |
887 |
int lHandle = ((Integer)layerTableRecord.get(0)).intValue(); |
888 |
if (lHandle==layer) {
|
889 |
layerName = (String)layerTableRecord.get(1); |
890 |
} |
891 |
} |
892 |
return layerName;
|
893 |
} |
894 |
|
895 |
/**
|
896 |
* Returns the color of the layer of a DWG object
|
897 |
*
|
898 |
* @param entity DWG object which we want to know its layer color
|
899 |
* @return int Layer color of the DWG object in the Autocad color code
|
900 |
*/
|
901 |
public int getColorByLayer(DwgObject entity) { |
902 |
int colorByLayer = 0; |
903 |
int layer = entity.getLayerHandle();
|
904 |
for (int j=0;j<layerTable.size();j++) { |
905 |
Vector layerTableRecord = (Vector)layerTable.get(j); |
906 |
int lHandle = ((Integer)layerTableRecord.get(0)).intValue(); |
907 |
if (lHandle==layer) {
|
908 |
colorByLayer = ((Integer)layerTableRecord.get(2)).intValue(); |
909 |
} |
910 |
} |
911 |
return colorByLayer;
|
912 |
} |
913 |
|
914 |
private void setDwgVersion() throws IOException { |
915 |
System.out.println("DwgFile.setDwgVersion() executed ..."); |
916 |
File file = new File(fileName); |
917 |
FileInputStream fileInputStream = new FileInputStream(file); |
918 |
FileChannel fileChannel = fileInputStream.getChannel();
|
919 |
long channelSize = fileChannel.size();
|
920 |
ByteBuffer byteBuffer = fileChannel.map(FileChannel.MapMode.READ_ONLY, 0, channelSize); |
921 |
byte[] versionBytes = {byteBuffer.get(0), byteBuffer.get(1), byteBuffer.get(2), byteBuffer.get(3), |
922 |
byteBuffer.get(4), byteBuffer.get(5)}; |
923 |
ByteBuffer versionByteBuffer = ByteBuffer.wrap(versionBytes); |
924 |
String versionString = readDwgVersion(versionByteBuffer);
|
925 |
String version;
|
926 |
if (versionString.equals("AC1009")) { |
927 |
version = new String("R12"); |
928 |
} else if (versionString.equals("AC1010")) { |
929 |
version = new String("R12+"); |
930 |
} else if (versionString.equals("AC1012")) { |
931 |
version = new String("R13"); |
932 |
} else if (versionString.equals("AC1014")) { |
933 |
version = new String("R14"); |
934 |
} else if (versionString.equals("AC1015")) { |
935 |
version = new String("R15"); |
936 |
} else {
|
937 |
version = new String("Unknown"); |
938 |
} |
939 |
this.dwgVersion = version;
|
940 |
} |
941 |
|
942 |
private String readDwgVersion(ByteBuffer versionBuffer) { |
943 |
String[] bs = new String[versionBuffer.capacity()]; |
944 |
String sv = ""; |
945 |
for (int i=0; i<versionBuffer.capacity(); i++) { |
946 |
bs[i] = new String(new byte[]{(byte)(versionBuffer.get(i))}); |
947 |
sv = sv + bs[i]; |
948 |
} |
949 |
return sv;
|
950 |
} |
951 |
|
952 |
/**
|
953 |
* Test if the DWG file is 2D or 3D. If there is any object with a non cero
|
954 |
* elevation value, the file is considered 3D.
|
955 |
*/
|
956 |
public void testDwg3D() { |
957 |
for (int i=0;i<dwgObjects.size();i++) { |
958 |
DwgObject obj = (DwgObject)dwgObjects.get(i); |
959 |
double z = 0.0; |
960 |
if (obj instanceof DwgArc) { |
961 |
z = ((DwgArc)obj).getCenter()[2];
|
962 |
if (z!=0.0) dwg3DFile = true; |
963 |
} else if (obj instanceof DwgAttrib) { |
964 |
z = ((DwgAttrib)obj).getElevation(); |
965 |
if (z!=0.0) dwg3DFile = true; |
966 |
} else if (obj instanceof DwgBlockHeader) { |
967 |
z = ((DwgBlockHeader)obj).getBasePoint()[2];
|
968 |
if (z!=0.0) dwg3DFile = true; |
969 |
} else if (obj instanceof DwgCircle) { |
970 |
z = ((DwgCircle)obj).getCenter()[2];
|
971 |
if (z!=0.0) dwg3DFile = true; |
972 |
} else if (obj instanceof DwgEllipse) { |
973 |
z = ((DwgEllipse)obj).getCenter()[2];
|
974 |
if (z!=0.0) dwg3DFile = true; |
975 |
} else if (obj instanceof DwgInsert) { |
976 |
z = ((DwgInsert)obj).getInsertionPoint()[2];
|
977 |
if (z!=0.0) dwg3DFile = true; |
978 |
} else if (obj instanceof DwgLine) { |
979 |
if (!((DwgLine)obj).isZflag()) {
|
980 |
double z1 = ((DwgLine)obj).getP1()[2]; |
981 |
double z2 = ((DwgLine)obj).getP2()[2]; |
982 |
if (z1!=0.0 || z2!=0.0) dwg3DFile = true; |
983 |
} |
984 |
//} else if (obj instanceof DwgLinearDimension) {
|
985 |
// z = ((DwgLinearDimension)obj).getElevation();
|
986 |
// if (z!=0.0) dwg3DFile = true;
|
987 |
} else if (obj instanceof DwgLwPolyline) { |
988 |
z = ((DwgLwPolyline)obj).getElevation(); |
989 |
if (z!=0.0) dwg3DFile = true; |
990 |
} else if (obj instanceof DwgMText) { |
991 |
z = ((DwgMText)obj).getInsertionPoint()[2];
|
992 |
if (z!=0.0) dwg3DFile = true; |
993 |
} else if (obj instanceof DwgPoint) { |
994 |
z = ((DwgPoint)obj).getPoint()[2];
|
995 |
if (z!=0.0) dwg3DFile = true; |
996 |
} else if (obj instanceof DwgPolyline2D) { |
997 |
z = ((DwgPolyline2D)obj).getElevation(); |
998 |
if (z!=0.0) dwg3DFile = true; |
999 |
} else if (obj instanceof DwgPolyline3D) { |
1000 |
if (((DwgPolyline3D)obj).getPts()!=null) { |
1001 |
double[][] pts = ((DwgPolyline3D)obj).getPts(); |
1002 |
for (int j=0;j<pts.length;j++) { |
1003 |
z = pts[j][2];
|
1004 |
if (z!=0.0) dwg3DFile = true; |
1005 |
} |
1006 |
} |
1007 |
} else if (obj instanceof DwgSolid) { |
1008 |
z = ((DwgSolid)obj).getElevation(); |
1009 |
if (z!=0.0) dwg3DFile = true; |
1010 |
} else if (obj instanceof DwgSpline) { |
1011 |
double[][] pts = ((DwgSpline)obj).getControlPoints(); |
1012 |
for (int j=0;j<pts.length;j++) { |
1013 |
z = pts[j][2];
|
1014 |
if (z!=0.0) dwg3DFile = true; |
1015 |
} |
1016 |
} else if (obj instanceof DwgText) { |
1017 |
z = ((DwgText)obj).getElevation(); |
1018 |
if (z!=0.0) dwg3DFile = true; |
1019 |
} |
1020 |
} |
1021 |
} |
1022 |
|
1023 |
/**
|
1024 |
* Add a DWG section offset to the dwgSectionOffsets vector
|
1025 |
*
|
1026 |
* @param key Define the DWG section
|
1027 |
* @param seek Offset of the section
|
1028 |
* @param size Size of the section
|
1029 |
*/
|
1030 |
public void addDwgSectionOffset(String key, int seek, int size) { |
1031 |
DwgSectionOffset dso = new DwgSectionOffset(key, seek, size);
|
1032 |
dwgSectionOffsets.add(dso); |
1033 |
} |
1034 |
|
1035 |
/**
|
1036 |
* Returns the offset of DWG section given by its key
|
1037 |
*
|
1038 |
* @param key Define the DWG section
|
1039 |
* @return int Offset of the section in the DWG file
|
1040 |
*/
|
1041 |
public int getDwgSectionOffset(String key) { |
1042 |
int offset = 0; |
1043 |
for (int i=0; i<dwgSectionOffsets.size(); i++) { |
1044 |
DwgSectionOffset dso = (DwgSectionOffset)dwgSectionOffsets.get(i); |
1045 |
String ikey = dso.getKey();
|
1046 |
if (key.equals(ikey)) {
|
1047 |
offset = dso.getSeek(); |
1048 |
break;
|
1049 |
} |
1050 |
} |
1051 |
return offset;
|
1052 |
} |
1053 |
|
1054 |
/**
|
1055 |
* Add a DWG object offset to the dwgObjectOffsets vector
|
1056 |
*
|
1057 |
* @param handle Object handle
|
1058 |
* @param offset Offset of the object data in the DWG file
|
1059 |
*/
|
1060 |
public void addDwgObjectOffset(int handle, int offset) { |
1061 |
DwgObjectOffset doo = new DwgObjectOffset(handle, offset);
|
1062 |
dwgObjectOffsets.add(doo); |
1063 |
} |
1064 |
|
1065 |
/**
|
1066 |
*
|
1067 |
* Add a DWG object to the dwgObject vector
|
1068 |
*
|
1069 |
* @param dwgObject DWG object
|
1070 |
*/
|
1071 |
public void addDwgObject(DwgObject dwgObject){ |
1072 |
dwgObjects.add(dwgObject); |
1073 |
} |
1074 |
|
1075 |
/**
|
1076 |
* Add a DWG class to the dwgClasses vector
|
1077 |
*
|
1078 |
* @param dwgClass DWG class
|
1079 |
*/
|
1080 |
public void addDwgClass(DwgClass dwgClass){ |
1081 |
System.out.println("DwgFile.addDwgClass() executed ..."); |
1082 |
dwgClasses.add(dwgClass); |
1083 |
} |
1084 |
|
1085 |
/**
|
1086 |
* @return Returns the dwgObjectOffsets.
|
1087 |
*/
|
1088 |
public Vector getDwgObjectOffsets() { |
1089 |
return dwgObjectOffsets;
|
1090 |
} |
1091 |
/**
|
1092 |
* @return Returns the dwgObjects.
|
1093 |
*/
|
1094 |
public Vector getDwgObjects() { |
1095 |
return dwgObjects;
|
1096 |
} |
1097 |
/**
|
1098 |
* @return Returns the fileName.
|
1099 |
*/
|
1100 |
public String getFileName() { |
1101 |
return fileName;
|
1102 |
} |
1103 |
/**
|
1104 |
* @return Returns the dwg3DFile.
|
1105 |
*/
|
1106 |
public boolean isDwg3DFile() { |
1107 |
return dwg3DFile;
|
1108 |
} |
1109 |
/**
|
1110 |
* @param dwg3DFile The dwg3DFile to set.
|
1111 |
*/
|
1112 |
public void setDwg3DFile(boolean dwg3DFile) { |
1113 |
this.dwg3DFile = dwg3DFile;
|
1114 |
} |
1115 |
} |