def InputAngleWithPlane(angle, axis, pos, ncopies, axial_shift, title): axis_type = 0 # not one of the three if axis == geom.Point3D(0, 0, 1): axis_type = 1 elif axis == geom.Point3D(0, -1, 0): axis_type = 2 elif axis == geom.Point3D(1, 0, 0): axis_type = 3 while (True): dlg = AngleAndPlaneDlg(angle, axis, axis_type, pos, ncopies, axial_shift, title) ret = dlg.ShowModal() angle, axis, axis_type, pos, ncopies, axial_shift = dlg.GetAllValues() if ret == wx.ID_OK: return True, angle, axis, pos, ncopies, axial_shift elif ret == dlg.rbXy.GetId(): continue elif ret == dlg.rbXz.GetId(): continue elif ret == dlg.rbYz.GetId(): continue elif ret == dlg.rbOther.GetId(): continue elif ret == dlg.btnPick.GetId(): p = wx.GetApp().PickPosition("Pick Position To Rotate About") if p != None: pos = p elif ret == dlg.btnVectorPick.GetId(): p = wx.GetApp().PickPosition("Pick Position On Rotation Axis") if p != None: v = p - pos if v.Length() < 0.01: wx.MessageBox('Axis Point Too Close to Position') else: axis = v.Normalized() else: return False, None, None, None, None, None
def GetTwoAxes(self, flattened_onto_screen, plane): plane_mode = self.ChooseBestPlane(plane) orimat = self.viewport.cad.GetDrawMatrix(False) if plane_mode == 0: vx = geom.Point3D(1, 0, 0).Transformed(orimat) vy = geom.Point3D(0, 1, 0).Transformed(orimat) elif plane_mode == 1: vx = geom.Point3D(1, 0, 0).Transformed(orimat) vy = geom.Point3D(0, 0, 1).Transformed(orimat) elif plane_mode == 2: vx = geom.Point3D(0, 1, 0).Transformed(orimat) vy = geom.Point3D(0, 0, 1).Transformed(orimat) # find closest between vx and vy to screen y dpx = vx * self.vertical dpy = vy * self.vertical if math.fabs(dpx) > math.fabs(dpy): vtemp = geom.Point3D(vx.x, vx.y, vx.z) vx = vy vy = vtemp # make sure vz is towards us if (vx ^ vy ) * self.forwards_vector() > 0: vx = -vx if flattened_onto_screen: f = self.forwards_vector().Normalized() vx = geom.Point3D(vx - (f * (f * vx))).Normalized() vy = geom.Point3D(vy - (f * (f * vy))).Normalized() r = rightwards_vector() if math.fabs(vy * r) > math.fabs(vx * r): vtemp = geom.Point3D(vx.x, vx.y, vx.z) vx = vy vy = vtemp return vx, vy, plane_mode
def InputMirrorPlane(axis, pos, copy, title): axis_type = 0 # not one of the three if axis == geom.Point3D(1, 0, 0): axis_type = 1 elif axis == geom.Point3D(0, 1, 0): axis_type = 2 elif axis == geom.Point3D(0, 0, 1): axis_type = 3 while (True): dlg = MirrorDlg(axis, pos, axis_type, copy, title) ret = dlg.ShowModal() axis, pos, axis_type, copy = dlg.GetAllValues() if ret == wx.ID_OK: return True, axis, pos, copy elif ret == dlg.rbH.GetId(): continue elif ret == dlg.rbV.GetId(): continue elif ret == dlg.rbZ.GetId(): continue elif ret == dlg.rbOther.GetId(): continue elif ret == dlg.btnPick.GetId(): p = wx.GetApp().PickPosition("Pick Position To Mirror About") if p != None: pos = p elif (dlg.btnVectorPick != None) and (ret == dlg.btnVectorPick.GetId()): p = wx.GetApp().PickPosition("Pick Position On Mirror Axis") if p != None: v = p - pos if v.Length() < 0.01: wx.MessageBox('Axis Point Too Close to Position') else: axis = v.Normalized() else: return False, None, None, None
def OnGlCommands(self, select, marked, no_color): if self.texture_number == None: image = wx.Image(self.filepath) if not image.IsOk(): self.texture_number = 0 return self.width = image.GetWidth() self.height = image.GetHeight() if self.bottom_left == None: self.bottom_left = geom.Point3D(0, 0, 0) self.bottom_right = geom.Point3D(self.width, 0, 0) self.top_right = geom.Point3D(self.width, self.height, 0) self.top_left = geom.Point3D(0, self.height, 0) self.texture_number, self.textureWidth = cad.GenTexture( image.GetData(), None, self.width, self.height, image.HasAlpha()) if self.texture_number == 0: return if self.bottom_left != None: cad.DrawImageQuads(self.width, self.height, self.textureWidth, self.texture_number, self.bottom_left, self.bottom_right, self.top_right, self.top_left, self.opacity, no_color, marked)
def GetAllValues(self): angle = self.angle_ctrl.GetValue() if self.rbXy.GetValue(): axis = geom.Point3D(0, 0, 1) axis_type = 1 elif self.rbXz.GetValue(): axis = geom.Point3D(0, -1, 0) axis_type = 2 elif self.rbYz.GetValue(): axis = geom.Point3D(1, 0, 0) axis_type = 3 else: if self.vectorx == None: axis = self.axis else: axis = geom.Point3D(self.vectorx.GetValue(), self.vectory.GetValue(), self.vectorz.GetValue()) axis_type = 0 pos = geom.Point3D(self.posx.GetValue(), self.posy.GetValue(), self.posz.GetValue()) ncopies = None if self.ncopies: ncopies = int(self.txt_num_copies.GetValue()) axial_shift = self.axial_shift_ctrl.GetValue() return angle, axis, axis_type, pos, ncopies, axial_shift
def AddPoint(self, d): if (self.drawing_mode == LineDrawingMode) or (self.drawing_mode == ArcDrawingMode): # edit the end of the previous item to be the start of the arc # this only happens if we are drawing tangents to other objects # really need to fill the gap with whatever we are tangent around # ellipse,arc,spline or whatever if (self.TempObject() != None) and (self.prev_object != None): if (self.prev_object != None): spos = self.TempObject().GetStartPoint() epos = self.prev_object.GetEndPoint() tanobject = self.start_pos.GetObject1() if self.start_pos.type == cad.DigitizeType.DIGITIZE_TANGENT_TYPE and ( tanobject != None): if tanobject.GetType() == cad.OBJECT_TYPE_SKETCH_LINE: #((HLine*)prev_object)->B = p; pass elif tanobject.GetType() == cad.OBJECT_TYPE_SKETCH_ARC: tanobject.A = geom.Point3D(spos) tanobject.B = geom.Point3D(epos) self.AddToTempObjects(tanobject) elif tanobject.GetType() == cad.OBJECT_TYPE_CIRCLE: arc = cad.NewArc(spos, epos, tanobject.axis, tanobject.C) arc.A = geom.Point3D(spos) arc.B = geom.Point3D(epos) self.AddToTempObjects(arc) Drawing.AddPoint(self, d)
def __init__(self, sketch=0): SketchOp.__init__(self, sketch) self.tool_on_side = PROFILE_LEFT_OR_OUTSIDE self.cut_mode = PROFILE_CLIMB self.auto_roll_radius = 2.0 self.auto_roll_on = True self.auto_roll_off = True self.roll_on_point = geom.Point3D(0, 0, 0) self.roll_off_point = geom.Point3D(0, 0, 0) self.start_given = False self.end_given = False self.start = geom.Point3D(0, 0, 0) self.end = geom.Point3D(0, 0, 0) self.sort_sketches = True self.tags = None self.offset_extra = 0.0 self.do_finishing_pass = False self.only_finishing_pass = False self.finishing_h_feed_rate = 100.0 self.finishing_cut_mode = PROFILE_CONVENTIONAL self.finishing_step_down = 1.0 self.end_beyond_full_profile = False self.extend_at_start = 0.0 self.extend_at_end = 0.0 self.lead_in_line_len = 0.0 self.lead_out_line_len = 0.0
def CopyFrom(self, o): self.filepath = o.filepath self.bottom_left = geom.Point3D(o.bottom_left) self.bottom_right = geom.Point3D(o.bottom_right) self.top_right = geom.Point3D(o.top_right) self.top_left = geom.Point3D(o.top_left) self.opacity = o.opacity Object.CopyFrom(self, o)
def AddTriangleToSketch(x0, y0, z0, x1, y1, z1, x2, y2, z2): p0 = geom.Point3D(x0, y0, z0) p1 = geom.Point3D(x1, y1, z1) p2 = geom.Point3D(x2, y2, z2) if p0 == p1: return if p1 == p2: return if p2 == p0: return stl_to_add_to.Add(p0, p1, p2)
def Mirror(): if cad.GetNumSelected() == 0: wx.GetApp().PickObjects('Pick objects to mirror') if cad.GetNumSelected() == 0: return config = HeeksConfig() selected_items = cad.GetSelectedObjects() cad.ClearSelection(False) copy = config.ReadBool("MirrorCopy", False) axis = geom.Point3D(0, 0, 1) pos = geom.Point3D(0, 0, 0) axis.x = config.ReadFloat("MirrorAxisX", 1.0) axis.y = config.ReadFloat("MirrorAxisY", 0.0) axis.z = config.ReadFloat("MirrorAxisZ", 0.0) pos.x = config.ReadFloat("MirrorPosX", 0.0) pos.y = config.ReadFloat("MirrorPosY", 0.0) pos.z = config.ReadFloat("MirrorPosZ", 0.0) result, axis, pos, copy = InputMirrorPlane(axis, pos, copy, 'Mirror') if not result: return config.WriteBool("MirrorCopy", copy) config.WriteFloat("MirrorAxisX", axis.x) config.WriteFloat("MirrorAxisY", axis.y) config.WriteFloat("MirrorAxisZ", axis.z) config.WriteFloat("MirrorPosX", pos.x) config.WriteFloat("MirrorPosY", pos.y) config.WriteFloat("MirrorPosZ", pos.z) cad.StartHistory() mat = geom.Matrix() x, y = axis.ArbitraryAxes() axis_mat = geom.Matrix(pos, x, y) inv_mat = axis_mat.Inverse() mat.Multiply(inv_mat) # transform so axis goes to z axis mat.Scale3(1.0, 1.0, -1.0) # mirror in z axis mat.Multiply(axis_mat) # transform back to where it was for object in selected_items: if copy: if object.CanBeCopied(): object = object.MakeACopy() object.Transform(mat) cad.AddUndoably(object) else: cad.TransformUndoably(object, mat) cad.EndHistory()
def OnGlCommands(self, select, marked, no_color): if marked and not select: tool = Tool.FindTool(self.tool_number) if tool == None: return radius = tool.CuttingRadius(True) global circle_sketch global arc1 global arc2 # get 3d position from the point objects, sorted by distance from camera forwards = wx.GetApp( ).frame.graphics_canvas.viewport.view_point.Forwards() lens_point = wx.GetApp( ).frame.graphics_canvas.viewport.view_point.lens_point posns = [] for point in self.points: object = cad.GetObjectFromId(cad.OBJECT_TYPE_POINT, point) if object == None: continue pos = object.GetStartPoint() dotp = (lens_point - pos) * forwards posns.append(DotpAndPos(dotp, pos)) posns = sorted(posns) for dotp_and_pos in posns: pos = dotp_and_pos.pos p0 = pos + geom.Point3D(-radius, 0, 0) p1 = pos + geom.Point3D(radius, 0, 0) if circle_sketch == None: circle_sketch = cad.NewSketch() arc1 = cad.NewArc(p0, p1, geom.Point3D(0, 0, 1), pos) arc2 = cad.NewArc(p1, p0, geom.Point3D(0, 0, 1), pos) circle_sketch.Add(arc1) circle_sketch.Add(arc2) else: arc1.SetStartPoint(p0) arc1.SetEndPoint(p1) arc1.SetCentrePoint(pos) arc2.SetStartPoint(p1) arc2.SetEndPoint(p0) arc2.SetCentrePoint(pos) cad.Material(cad.Color(255, 255, 0)).glMaterial(1.0) cad.DrawEnableLighting() cad.DrawDisableDepthTesting() cad.DrawEnableCullFace() cad.Sketch.RenderAsExtrusion(circle_sketch, self.start_depth, self.final_depth) cad.DrawDisableCullFace() cad.DrawEnableDepthTesting() cad.DrawDisableLighting()
def add_arc(self, x, y, z, i, j, k, r = None, d = None): arc = cam.NewPathArc() arc.c = geom.Point3D(self.oldp) if i != None: arc.c.x = float(i) - self.oldp.x if j != None: arc.c.y = float(j) - self.oldp.y if k != None: arc.c.z = float(k) - self.oldp.z if x != None: self.oldp.x = float(x) if y != None: self.oldp.y = float(y) if z != None: self.oldp.z = float(z) arc.point = geom.Point3D(self.oldp) if r != None: arc.radius = float(r) if d != None: arc.dir = int(d) self.current_path.AddPathObject(arc)
def GetMatrices(self, matrices): m2 = geom.Matrix() shift_m2 = geom.Matrix() shift_m2.Translate(geom.Point3D(self.x_shift2, self.y_shift2, 0.0)) shift_m1 = geom.Matrix() shift_m1.Translate(geom.Point3D(self.x_shift1, self.y_shift1, 0.0)) for j in range(0, self.copies2): m = geom.Matrix(m2) for i in range(0, self.copies1): matrices.append(m) m = m * shift_m1 m2 = m2 * shift_m2
def GetTmFromCurve(curve): if curve == None: return ps = GetMinXPoint(curve) pe = GetMaxXPoint(curve) vx = pe - ps vx.Normalize() vy = ~vx o = geom.Point3D(ps.x, ps.y, 0.0) vvx = geom.Point3D(vx.x, vx.y, 0.0) vvy = geom.Point3D(vy.x, vy.y, 0.0) tm = geom.Matrix(o, vvx, vvy) return tm.Inverse()
def CalculatePolygon(self, p0, p1, zdir): if p0 == p1: return if self.TempObject() == None: return if self.TempObject().GetNumChildren() != self.number_of_side_for_polygon: self.ClearSketch() lines = [] if self.TempObject().GetNumChildren() > 0: object = self.TempObject().GetFirstChild() for i in range(0, self.number_of_side_for_polygon): lines.append(object) object = self.TempObject().GetNextChild() else: for i in range(0, self.number_of_side_for_polygon): line = cad.NewLine(geom.Point3D(0, 0, 0), geom.Point3D(0, 0, 0)) lines.append(line) self.TempObject().Add(line) radius = p0.Dist(p1) sideAngle=0 if self.polygon_inscribed: # inscribed circle sideAngle = 2.0 * math.pi / self.number_of_side_for_polygon radius = radius/math.cos(sideAngle/2) for i in range(0, self.number_of_side_for_polygon): xdir = p1 - p0 xdir.Normalize() ydir = zdir ^ xdir angle0 = (sideAngle * i)+(sideAngle/2) angle1 = (sideAngle * (i+1))+(sideAngle/2) lines[i].A = p0 + xdir * ( math.cos(angle0) * radius ) + ydir * ( math.sin(angle0) * radius ) if i == self.number_of_side_for_polygon - 1: lines[i].B = lines[0].A lines[i].B = p0 + xdir * ( math.cos(angle1) * radius ) + ydir * ( math.sin(angle1) * radius ) else: # excribed circle for i in range(0, self.number_of_side_for_polygon): xdir = p1 - p0 xdir.Normalize() ydir = zdir ^ xdir angle0 = 2.0 * math.pi / self.number_of_side_for_polygon * i angle1 = 2.0 * math.pi / self.number_of_side_for_polygon * (i+1) lines[i].A = p0 + xdir * ( math.cos(angle0) * radius ) + ydir * ( math.sin(angle0) * radius ) if i == self.number_of_side_for_polygon - 1: lines[i].B = lines[0].A lines[i].B = p0 + xdir * ( math.cos(angle1) * radius ) + ydir * ( math.sin(angle1) * radius )
def RenderGrid(cad, view_point, plane=0): if cad.grid_mode == 1: cc = cad.background_color[0].best_black_or_white() v_bg = geom.Point3D(bg.red, bg.green, bg.blue) v_cc = geom.Point3D(cc.red, cc.green, cc.blue) v_contrast = v_cc - v_bg unit_contrast = v_contrast.Normalized() l1, l2, l3 = 100, 0, 10 if v_cc * geom.Point3D(1, 1, 1) > 0: l1, l2, l3 = 200, 130, 80 if l1 > v_contrast.Magnitude(): l1 = v_contrast.Magnitude() if l2 > v_contrast.Magnitude(): l2 = v_contrast.Magnitude() if l3 > v_contrast.Magnitude(): l3 = v_contrast.Magnitude() uf = (view_point.forwards_vector()).Normalized() vx, vy = view_point.GetTwoAxes(false, plane) datum = geom.Point3D(0, 0, 0) orimat = cad.GetDrawMatrix(False) datum = datum.Transformed(orimat) orimat = make_matrix(datum, vx, vy) v_up = geom.Point3D(0, 0, 1).Transformed(orimat) fufz = math.fabs(uf * v_up) if fufz < 0.7: there = (fufz - 0.3) / 0.4 l1 *= there l2 *= there v_gc1 = v_bg + unit_contrast * l1 v_gc2 = v_bg + unit_contrast * l2 v_gc3 = v_bg + unit_contrast * l3 glColor3ub(v_gc3.x, v_gc3.y, v_gc3.z) RenderGrid2(cad, view_point, 200, False, True, None, None, 0, plane) glColor3ub(v_gc2.x, v_gc2.y, v_gc2.z) RenderGrid2(cad, view_point, 20, True, False, None, None, 0, plane) glColor3ub(v_gc1.x, v_gc1.y, v_gc1.z) RenderGrid2(cad, view_point, 20, False, False, None, None, 0, plane) elif cad.grid_mode == 2 or cad.grid_mode == 3: bg = cad.background_color[0] cc = bg.best_black_or_white() light_color = ((cc.red + cc.green + cc.blue) > 384) cad.EnableBlend() RenderGrid2(cad, view_point, 200, False, True, bg, cc, 40 if light_color else 10, plane) RenderGrid2(cad, view_point, 20, True, False, bg, cc, 80 if light_color else 20, plane) RenderGrid2(cad, view_point, 20, False, False, bg, cc, 120 if light_color else 30, plane) cad.DisableBlend()
def Scale(): centre_Pos = geom.Point3D(0, 0, 0) if cad.GetNumSelected() == 0: wx.GetApp().PickObjects('Pick objects to scale') if cad.GetNumSelected() == 0: return config = HeeksConfig() selected_items = cad.GetSelectedObjects() cad.ClearSelection(False) scale_factor = config.ReadFloat('ScaleFactor', 1.0) copy = config.ReadBool("ScaleCopy", False) pos = geom.Point3D(0, 0, 0) pos.x = config.ReadFloat("ScaleAboutPosX", 0.0) pos.y = config.ReadFloat("ScaleAboutPosY", 0.0) pos.z = config.ReadFloat("ScaleAboutPosZ", 0.0) result, pos, scale_factor, copy = InputScale(pos, scale_factor, copy, 'Scale') if not result: return config.WriteFloat("ScaleFactor", scale_factor) config.WriteBool("ScaleCopy", copy) config.WriteFloat("ScaleAboutPosX", pos.x) config.WriteFloat("ScaleAboutPosY", pos.y) config.WriteFloat("ScaleAboutPosZ", pos.z) cad.StartHistory() mat = geom.Matrix() mat.Translate(-pos) mat.Scale(scale_factor) mat.Translate(pos) for object in selected_items: if copy: if object.CanBeCopied(): object = object.MakeACopy() object.Transform(mat) cad.AddUndoably(object) else: cad.TransformUndoably(object, mat) cad.EndHistory()
def MakeFromTwoPoints(self, p0, p1): self.p = p self.v = geom.Point3D(p0, p1) self.length = v.magnitude() self.box = geom.Box3D() self.GetBox(self.box) self.ok = length > geom.tolerance
def construct_from_3_points(self, origin, x_axis, y_axis): unit_x = x_axis unit_x.Normalize() t = unit_x.x * y_axis.x + unit_x.y * y_axis.y + unit_x.z * y_axis.z y_orthogonal = geom.Point3D(y_axis.x - unit_x.x * t, y_axis.y - unit_x.y * t, y_axis.z - unit_x.z * t) unit_y = copy.deepcopy(y_orthogonal) unit_y.Normalize() unit_z = unit_x ^ y_orthogonal unit_z.Normalize() self.m = [] self.m.append(unit_x.x) self.m.append(unit_y.x) self.m.append(unit_z.x) self.m.append(origin.x) self.m.append(unit_x.y) self.m.append(unit_y.y) self.m.append(unit_z.y) self.m.append(origin.y) self.m.append(unit_x.z) self.m.append(unit_y.z) self.m.append(unit_z.z) self.m.append(origin.z) self.m.append(0) self.m.append(0) self.m.append(0) self.m.append(1)
def OnSetOriginPoints(self, three_points): mat = cad.GetDrawMatrix(False) o = geom.Point3D(0,0,0).Transformed(mat) x = geom.Point3D(1,0,0).Transformed(mat) - o y = geom.Point3D(0,1,0).Transformed(mat) - o new_object = cad.NewCoordinateSystem("Coordinate System", o, x, y) cad.ClearSelection() self.SetInputMode(self.select_mode) # and pick from three points result = self.MakeOriginFromPickPoints(new_object, three_points) if result: cad.AddUndoably(new_object) cad.Select(new_object) else: cad.DeleteInternalObject(new_object)
def add_line(self, x, y, z, a = None, b = None, c = None): line = cam.NewPathLine() if x != None: self.oldp.x = float(x) if y != None: self.oldp.y = float(y) if z != None: self.oldp.z = float(z) line.point = geom.Point3D(self.oldp) self.current_path.AddPathObject(line)
def __init__(self, nccode): self.nccode = nccode self.t = None self.oldp = geom.Point3D(0,0,50) self.current_block = None self.current_path = None self.next_line_number = 0
def GetXYZScale(self): sx = math.sqrt(self.m[0] * self.m[0] + self.m[1] * self.m[1] + self.m[2] * self.m[2]) sy = math.sqrt(self.m[4] * self.m[4] + self.m[5] * self.m[5] + self.m[6] * self.m[6]) sz = math.sqrt(self.m[8] * self.m[8] + self.m[9] * self.m[9] + self.m[10] * self.m[10]) return geom.Point3D(sx, sy, sz)
def SetProjection2(self, use_depth_testing): rad = 0.0 box = geom.Box3D() if use_depth_testing: self.viewport.cad.GetBox(box) box.InsertBox(self.extra_depth_box) box.InsertBox(self.extra_view_box) if use_depth_testing == False: self.near_plane = 0.0 self.far_plane = 100000000.0 rad = 2000000.0 elif box.valid == False: self.near_plane = 0.2 self.far_plane = 2000.0 rad = 1000.0 else: x, y, z = box.Centre() box_centre = geom.Point3D(x, y, z) rad = box.Radius() to_centre_of_box = geom.Point3D(self.lens_point, box_centre) f = self.forwards_vector() f.Normalize() distance = to_centre_of_box * f if self.section: rad = rad /100 self.near_plane = distance - rad self.far_plane = distance + rad size = self.viewport.GetViewportSize() w = size.GetWidth()/self.pixel_scale h = size.GetHeight()/self.pixel_scale s = math.sqrt(w*w + h*h) self.near_plane = self.near_plane - s/2 self.far_plane = self.far_plane + s/2 hw = float(size.GetWidth())/2 hh = float(size.GetHeight())/2 if self.perspective: fovy = self.view_angle if h>w and w>0: fovy = 2 * 180/math.pi * math.atan( math.tan(self.view_angle/2 * math.pi/180) * h/w) if self.near_plane < self.far_plane / 200: self.near_plane= self.far_plane /200 gluPerspective(fovy, w/h, self.near_plane, self.far_plane) else: glOrtho((-0.5 - hw)/self.pixel_scale, (hw+0.5)/self.pixel_scale, (-0.5-hh)/self.pixel_scale, (0.5+hh)/self.pixel_scale, self.near_plane, self.far_plane)
def GetRotationABC(self): if self.IsUnit(): return geom.Point3D(0.0, 0.0, 0.0) scale_xyz = self.GetXYZScale() if self.IsMirrored(): scale_xyz.x = -scale_xyz.x # solve for d and decide case and solve for a, b, c, e and f d = -self.m[8] / sz c = (1 - d) * (1 + d) if c > 0.001: # case 1 c = sqrt(c) a = self.m[10] / sz / c b = self.m[9] / sz / c ee = self.m[0] / sx / c f = self.m[4] / sy / c else: # case 2 d = -1 if (d < 0) else 1 c = 0 p = d * self.m[5] / sy - self.m[2] / sx q = d * self.m[6] / sy + self.m[1] / sx coef = math.sqrt(p * p + q * q) if coef > 0.001: a = q / coef b = p / coef ee = b f = -d * b else: # dependent pairs a = self.m[5] / sy b = -self.m[6] / sy ee = 1 f = 0 # solve and return ax, ay and az ax = math.atan2(b, a) ay = math.atan2(d, c) az = math.atan2(f, ee) return geom.Point3D(ax, ay, az)
def __init__(self, viewport): self.viewport = viewport self.initial_point = wx.Point() self.initial_pixel_scale = 0.0 self.perspective = 0.0 self.section = False self.lens_point = geom.Point3D(0, 0, 200) self.target_point = geom.Point3D(0, 0, 0) self.vertical = geom.Point3D(0, 1, 0) self.pixel_scale = 10.0 self.view_angle = 30.0 self.projm = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1] self.modelm = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1] self.window_rect = [0, 0, 0, 0] self.matrix_valid = False self.near_plane = 0.0 self.far_plane = 0.0 self.extra_depth_box = geom.Box3D() self.extra_view_box = geom.Box3D()
def GetDrawMatrix(self, get_the_appropriate_orthogonal): if get_the_appropriate_orthogonal: # choose from the three orthoganal possibilities, the one where it's z-axis closest to the camera direction vx, vy = self.current_viewport.view_point.GetTwoAxes(False, 0) o = geom.Point3D(0, 0, 0) if self.current_coordinate_system: o.Transform(self.current_coordinate_system.GetMatrix()) return geom.Matrix(o, vx, vy) mat = geom.Matrix() if self.current_coordinate_system: mat = self.current_coordinate_system.GetMatrix() return mat
def ReadXml(self): self.filepath = cad.GetXmlValue('filepath') if self.bottom_left == None: self.bottom_left = geom.Point3D(0, 0, 0) self.bottom_right = geom.Point3D(0, 0, 0) self.top_right = geom.Point3D(0, 0, 0) self.top_left = geom.Point3D(0, 0, 0) self.bottom_left.x = float(cad.GetXmlValue('x00')) self.bottom_left.y = float(cad.GetXmlValue('x01')) self.bottom_left.z = float(cad.GetXmlValue('x02')) self.bottom_right.x = float(cad.GetXmlValue('x10')) self.bottom_right.y = float(cad.GetXmlValue('x11')) self.bottom_right.z = float(cad.GetXmlValue('x12')) self.top_right.x = float(cad.GetXmlValue('x20')) self.top_right.y = float(cad.GetXmlValue('x21')) self.top_right.z = float(cad.GetXmlValue('x22')) self.top_left.x = float(cad.GetXmlValue('x30')) self.top_left.y = float(cad.GetXmlValue('x31')) self.top_left.z = float(cad.GetXmlValue('x32')) self.opacity = float(cad.GetXmlValue('opacity')) Object.ReadXml(self)
def __init__(self, p0, p1, p2=None): """ construct Plane from three points, from distance and normal ( Point3D ), or a point ( Point3D ) and a normal vector ( Point3D ) """ if p2 == None: if isinstance(p0, geom.Point3D): self.normal = p1 self.normal.Normalize() self.d = -(self.normal * p0) elif isinstance(p0, int) or isinatance(p0, float): self.normal = p1 mag = self.normal.Normalize() self.ok = self.normal != geom.Point3D(0.0, 0.0, 0.0) if self.ok: self.d = float(p0) / mag else: raise ValueError( "Point3D or float for first argument expected") else: # construct plane from 3 points self.normal = geom.Point3D(p0, p1) ^ geom.Point3D(p0, p2) self.normal.Normalize() self.ok = self.normal != geom.Point3D(0.0, 0.0, 0.0) self.d = -(self.normal * p0)
def ChooseBestPlane(self, plane): f = self.forwards_vector() orimat = self.viewport.cad.GetDrawMatrix(False) dp = [geom.Point3D(0, 0, 1).Transformed(orimat) * f, geom.Point3D(0, 1, 0).Transformed(orimat) * f, geom.Point3D(1, 0, 0).Transformed(orimat) * f] best_dp = 0.0 best_mode = -1 second_best_dp = 0.0 second_best_mode = -1 third_best_dp = 0.0 third_best_mode = -1 for i in range(0, 3): if best_mode == -1: best_mode = i best_dp = math.fabs(dp[i]) else: if math.fabs(dp[i])>best_dp: third_best_dp = second_best_dp third_best_mode = second_best_mode second_best_dp = best_dp second_best_mode = best_mode best_mode = i best_dp = math.fabs(dp[i]) else: if second_best_mode == -1: second_best_mode = i second_best_dp = math.fabs(dp[i]) else: if math.fabs(dp[i])>second_best_dp: third_best_dp = second_best_dp third_best_mode = second_best_mode second_best_dp = math.fabs(dp[i]) second_best_mode = i else: third_best_dp = math.fabs(dp[i]) third_best_mode = i; if plane == 0: return best_mode elif plane == 1: return second_best_mode return third_best_mode