예제 #1
0
 def check_tgc(self, name, expected_points):
     shape = self.lookup_shape(name)
     expected = Vector(expected_points)
     actual = cta.flatten_numbers(
         [shape.base, shape.height, shape.a, shape.b, shape.c, shape.d])
     if not expected.is_same(actual):
         self.fail("{0} != {1}".format(expected, actual))
예제 #2
0
 def __init__(self, name, sketch, revolve_center=None, revolve_axis=None, radius=None, angle=None, copy=False):
     Primitive.__init__(self, name=name)
     self.sketch = sketch
     self.revolve_center = Vector(revolve_center, copy=copy) if revolve_center else Vector.O3()
     self.revolve_axis = Vector(revolve_axis, copy=copy) if revolve_axis else Vector.Z3()
     self.radius = Vector(radius, copy=copy) if radius else Vector.X3()
     self.angle = 180 if angle is None else float(angle)
예제 #3
0
def hilbert_pipe(file_name,
                 size=10,
                 recursions=4,
                 dc=0.2,
                 direction=ZP,
                 variant=0,
                 x_vec=(1, 0, 0),
                 y_vec=(0, 1, 0),
                 z_vec=(0, 0, 1)):
    l = float(size) / (2**recursions)
    d = dc * l
    r = d
    points = [(x, d, 0, r) for x in generate_points(recursions,
                                                    direction=direction,
                                                    variant=variant,
                                                    x_vec=Vector(x_vec) * l,
                                                    y_vec=Vector(y_vec) * l,
                                                    z_vec=Vector(z_vec) * l)]
    with WDB(file_name, "3D Hilbert space filling curve with pipes") as brl_db:
        pipe_name = "hilbert_3d.s"
        brl_db.pipe(pipe_name, points=points)
        region_name = "hilbert_3d.r"
        brl_db.region(name=region_name,
                      tree=pipe_name,
                      rgb_color=(64, 180, 96))
예제 #4
0
 def __init__(self,
              name,
              base=(0, 0, 0),
              u_vec=(1, 0, 0),
              v_vec=(0, 1, 0),
              vertices=None,
              curves=None,
              copy=False):
     Primitive.__init__(self, name=name)
     self.base = Vector(base, copy=copy)
     self.u_vec = Vector(u_vec, copy=copy)
     self.v_vec = Vector(v_vec, copy=copy)
     if vertices is None:
         vertices = []
     elif not isinstance(vertices, list):
         vertices = list(vertices)
     for i in range(0, len(vertices)):
         vertices[i] = Vector(vertices[i], copy=copy)
     self.vertices = vertices
     if curves is None:
         curves = []
     elif not isinstance(curves, list):
         curves = list(curves)
     self.curves = curves
     for i in xrange(0, len(curves)):
         self.add_curve_segment(curves[i], segment_index=i, copy=copy)
예제 #5
0
def hilbert_3D_test():
    l = 1
    d = 0.2 * l
    r = d
    with WDB("hilbert_3d_test.g", "Hilbert-pipe 3D") as brl_db:
        for o1 in (-1, 1):
            for o2 in (-1, 1):
                for crt_dir in NEGATE:
                    points_generator = generate_points(2,
                                                       direction=crt_dir,
                                                       order=(o1, o2),
                                                       x_vec=(l, 0, 0),
                                                       y_vec=(0, l, 0),
                                                       z_vec=(0, 0, l))
                    segments = [(x, d, 0, r) for x in points_generator]
                    shape_name = "hilbert_pipe_{}{}{}{}{}.s".format(
                        o1, o2, *crt_dir)
                    region_name = "hilbert_pipe_{}{}{}{}{}.r".format(
                        o1, o2, *crt_dir)
                    if min(crt_dir) < 0:
                        rgb_color = Vector("255, 0, 0")
                    else:
                        rgb_color = Vector("0, 255, 0")
                    if o1 < 0 or o2 < 0:
                        rgb_color *= 0.3
                        rgb_color += 60
                    brl_db.pipe(shape_name, points=segments)
                    brl_db.region(name=region_name,
                                  tree=shape_name,
                                  rgb_color=tuple([int(c) for c in rgb_color]))
예제 #6
0
 def __init__(self, name, base=(0, 0, 0), height=(0, 0, 1), a_vec=(0, 1, 0),
              b_mag=0.5, base_neck_ratio=0.2, copy=False):
     Primitive.__init__(self, name=name)
     self.base = Vector(base, copy=copy)
     self.height = Vector(height, copy=copy)
     self.a_vec = Vector(a_vec, copy=copy)
     self.b_mag = b_mag
     self.base_neck_ratio = base_neck_ratio
예제 #7
0
 def angle_from_points(p1, p2, p3):
     """
     Calculates the angle p1-p2-p3. The result is in the range [0, pi]
     """
     p1 = Vector(p1, copy=False)
     p2 = Vector(p2, copy=False)
     p3 = Vector(p3, copy=False)
     return Triangle.angle_between_vectors(p1 - p2, p3 - p2)
예제 #8
0
 def __init__(self,
              name,
              center=(0, 0, 0),
              normal=(1, 0, 0),
              magnitude=1,
              copy=False):
     Primitive.__init__(self, name=name)
     self.center = Vector(center, copy=copy)
     self.normal = Vector(normal, copy=copy)
     self.magnitude = magnitude
예제 #9
0
def generate_points(iterations,
                    start_point=(0, 0, 0),
                    u_vec=(0, 1, 0),
                    v_vec=(0, 0, 1)):
    crt_point = Vector(start_point, copy=True)
    u_vec = Vector(u_vec, copy=False)
    v_vec = Vector(v_vec, copy=False)
    yield crt_point
    for x in generate_steps(iterations):
        crt_point = crt_point + (x[0] * u_vec) + (x[1] * v_vec)
        yield crt_point
예제 #10
0
 def __init__(self,
              name,
              base=(0, 0, 0),
              height=(0, 0, 1),
              r_base=0.5,
              r_end=0.2,
              copy=False):
     Primitive.__init__(self, name=name)
     self.base = Vector(base, copy=copy)
     self.height = Vector(height, copy=copy)
     self.r_base = r_base
     self.r_end = r_end
예제 #11
0
 def __init__(self,
              name,
              center=(0, 0, 0),
              n=(0, 0, 1),
              r_revolution=1,
              r_cross=0.2,
              copy=False):
     Primitive.__init__(self, name=name)
     self.center = Vector(center, copy=copy)
     self.n = Vector(n, copy=copy)
     self.r_revolution = r_revolution
     self.r_cross = r_cross
예제 #12
0
 def __init__(self,
              name,
              base=(0, 0, 0),
              height=(-1, 0, 0),
              breadth=(0, 0, 1),
              half_width=0.5,
              copy=False):
     Primitive.__init__(self, name=name)
     self.base = Vector(base, copy=copy)
     self.height = Vector(height, copy=copy)
     self.breadth = Vector(breadth, copy=copy)
     self.half_width = half_width
예제 #13
0
 def __init__(self,
              name,
              center=(0, 0, 0),
              n=(0, 0, 1),
              s_major=(0, 0.5, 0.5),
              r_revolution=1,
              r_minor=0.2,
              copy=False):
     Primitive.__init__(self, name=name)
     self.center = Vector(center, copy=copy)
     self.n = Vector(n, copy=copy)
     self.s_major = Vector(s_major, copy=copy)
     self.r_revolution = r_revolution
     self.r_minor = r_minor
예제 #14
0
class Superell(Primitive):

    def __init__(self,name, center=(0, 0, 0), a=(1, 0, 0), b=(0, 1, 0), c=(0, 0, 1), n=0, e=0, copy=False):
        Primitive.__init__(self, name=name)
        self.center = Vector(center, copy)
        self.a = Vector(a, copy)
        self.b = Vector(b, copy)
        self.c = Vector(c, copy)
        self.n = n
        self.e = e

    def __repr__(self):
        result = "{}({}, v={}, a={}, b={}, c={}, n={}, e={} )"
        return result.format(
            self.__class__.__name__, self.name, repr(self.center), repr(self.a),
            repr(self.b), repr(self.c), self.n, self.e
        )

    def update_params(self, params):
        params.update({
            "center": self.center,
            "a": self.a,
            "b": self.b,
            "c": self.c,
            "n": self.n,
            "e": self.e
        })

    def copy(self):
        return Superell(self.name, self.center, self.a, self.b, self.c, self.n, self.e, copy=True)

    def has_same_data(self, other):
        return self.e == other.e and \
               self.n == other.n and \
               self.center.is_same(other.center) and \
               self.a.is_same(other.a) and \
               self.b.is_same(other.b) and \
               self.c.is_same(other.c)

    @staticmethod
    def from_wdb(name, data):
        return Superell(
            name=name,
            center=data.v,
            a=data.a,
            b=data.b,
            c=data.c,
            n=data.n,
            e=data.e,
        )
예제 #15
0
 def __init__(self,
              name,
              base=(0, 0, 0),
              height=(0, 0, 1),
              n_major=(0, 1, 0),
              r_major=1,
              r_minor=0.5,
              copy=False):
     Primitive.__init__(self, name=name)
     self.base = Vector(base, copy=copy)
     self.height = Vector(height, copy=copy)
     self.n_major = Vector(n_major, copy=copy)
     self.r_major = r_major
     self.r_minor = r_minor
예제 #16
0
 def __init__(self, name, sketch, base=None, height=None, u_vec=None, v_vec=None, copy=False):
     Primitive.__init__(self, name=name)
     self.sketch = sketch
     self.base = Vector(base, copy=copy) if base else Vector.O3()
     self.height = Vector(height, copy=copy) if height else Vector.Z3()
     self.u_vec = Vector(u_vec, copy=copy) if u_vec else Vector.X3()
     self.v_vec = Vector(v_vec, copy=copy) if v_vec else Vector.Y3()
예제 #17
0
 def from_wdb(name, data):
     vertices = []
     for i in range(0, data.vert_count):
         vertices.append(Vector(data.verts[i]))
     result = Sketch(
         name=name, base=Vector(data.V), u_vec=Vector(data.u_vec), v_vec=Vector(data.v_vec), vertices=vertices
     )
     curves = data.curve
     for i in range(0, curves.count):
         curve = curves.segment[i]
         magic = librt.cast(curve, librt.POINTER(librt.struct_line_seg)).contents.magic
         reverse = bool(curves.reverse[i])
         result.add_curve_segment(magic, curve, reverse=reverse)
     return result
예제 #18
0
 def __init__(self,name, center=(0, 0, 0), a=(1, 0, 0), b=(0, 1, 0), c=(0, 0, 1), n=0, e=0, copy=False):
     Primitive.__init__(self, name=name)
     self.center = Vector(center, copy)
     self.a = Vector(a, copy)
     self.b = Vector(b, copy)
     self.c = Vector(c, copy)
     self.n = n
     self.e = e
예제 #19
0
 def __init__(self,
              name,
              mode=1,
              orientation=1,
              flags=0,
              vertices=None,
              faces=None,
              copy=False):
     Primitive.__init__(self, name=name)
     self.mode = mode
     self.orientation = orientation
     self.flags = flags
     if vertices is None:
         vertices = []
     elif not isinstance(vertices, list):
         vertices = list(vertices)
     for i in range(0, len(vertices)):
         vertices[i] = Vector(vertices[i], copy=copy)
     self.vertices = vertices
     if faces is None:
         faces = []
     elif not isinstance(faces, list):
         curves = list(faces)
     self.faces = faces
     for i in range(0, len(faces)):
         self.add_face(faces[i])
예제 #20
0
 def __new__(cls,
             name,
             base=(0, 0, 0),
             height=(0, 0, 1),
             radius=1,
             copy=False):
     base = Vector(base, copy=copy)
     height = Vector(height, copy=copy)
     a = height.construct_normal()
     b = a.cross(height)
     return TGC(name=name,
                base=base,
                height=height,
                a=a,
                b=b,
                c=a,
                d=b,
                copy=False)
예제 #21
0
class Grip(Primitive):
    def __init__(self,
                 name,
                 center=(0, 0, 0),
                 normal=(1, 0, 0),
                 magnitude=1,
                 copy=False):
        Primitive.__init__(self, name=name)
        self.center = Vector(center, copy=copy)
        self.normal = Vector(normal, copy=copy)
        self.magnitude = magnitude

    def __repr__(self):
        result = "{}({}, center={}, normal={}, magnitude={})"
        return result.format(self.__class__.__name__, self.name, self.center,
                             self.normal, self.magnitude)

    def update_params(self, params):
        params.update({
            "center": self.center,
            "normal": self.normal,
            "magnitude": self.magnitude
        })

    def copy(self):
        return Grip(self.name,
                    self.center,
                    self.normal,
                    self.magnitude,
                    copy=True)

    def has_same_data(self, other):
        return self.center.is_same(other.center) and \
               self.normal.is_same(other.normal) and \
               self.magnitude == other.magnitude

    @staticmethod
    def from_wdb(name, data):
        return Grip(name=name,
                    center=data.center,
                    normal=data.normal,
                    magnitude=data.mag)
예제 #22
0
def generate_points(iterations,
                    direction=XP,
                    order=(1, 1),
                    variant=0,
                    start_point=(0, 0, 0),
                    x_vec=(1, 0, 0),
                    y_vec=(0, 1, 0),
                    z_vec=(0, 0, 1)):
    crt_point = Vector(start_point, copy=True)
    x_vec = Vector(x_vec, copy=False)
    y_vec = Vector(y_vec, copy=False)
    z_vec = Vector(z_vec, copy=False)
    yield crt_point
    for step in generate_steps(iterations,
                               direction=direction,
                               order=order,
                               variant=variant):
        crt_point = crt_point + (step[0] * x_vec) + (step[1] *
                                                     y_vec) + (step[2] * z_vec)
        yield crt_point
예제 #23
0
 def __init__(self,
              name,
              file_name,
              x_dim=1,
              y_dim=1,
              z_dim=1,
              low_thresh=0,
              high_thresh=128,
              cell_size=(1, 1, 1),
              mat=Transform.unit(),
              copy=False):
     Primitive.__init__(self, name=name)
     if not os.path.isfile(file_name):
         raise ValueError("File {} does not exist !".format(file_name))
     self.file_name = file_name
     self.x_dim = x_dim
     self.y_dim = y_dim
     self.z_dim = z_dim
     self.low_thresh = low_thresh
     self.high_thresh = high_thresh
     self.cell_size = Vector(cell_size, copy=copy)
     self.mat = Transform(mat, copy=copy, force=True)
예제 #24
0
class Grip(Primitive):

    def __init__(self, name, center=(0, 0, 0), normal=(1, 0, 0), magnitude=1, copy=False):
        Primitive.__init__(self, name=name)
        self.center = Vector(center, copy=copy)
        self.normal = Vector(normal, copy=copy)
        self.magnitude = magnitude

    def __repr__(self):
        result = "{}({}, center={}, normal={}, magnitude={})"
        return result.format(
            self.__class__.__name__, self.name, self.center, self.normal, self.magnitude
        )

    def update_params(self, params):
        params.update({
            "center": self.center,
            "normal": self.normal,
            "magnitude": self.magnitude
        })

    def copy(self):
        return Grip(self.name, self.center, self.normal, self.magnitude, copy=True)

    def has_same_data(self, other):
        return self.center.is_same(other.center) and \
               self.normal.is_same(other.normal) and \
               self.magnitude == other.magnitude


    @staticmethod
    def from_wdb(name, data):
        return Grip(
            name=name,
            center=data.center,
            normal=data.normal,
            magnitude=data.mag
        )
예제 #25
0
 def vertex_index(self, value, copy=False):
     vertex_count = len(self.vertices)
     if isinstance(value, numbers.Integral):
         if value > vertex_count - 1:
             raise ValueError("Invalid vertex index: {}".format(value))
         return value
     value = Vector(value, copy=copy)
     if len(value) != 2:
         raise ValueError("Sketches need 2D vertexes, but got: {}".format(value))
     for i in range(0, vertex_count):
         if self.vertices[i].is_same(value):
             return i
     self.vertices.append(value)
     return vertex_count
예제 #26
0
 def __new__(cls, point=(0, 0, 1), field_strength=1, sweat=0, copy=False):
     """
     Parse a MetaballCtrlPoint from multiple possible inputs:
     >>> x = MetaballCtrlPoint("0, 0, 1", 1, 0)
     >>> x.point.is_same((0, 0, 1))
     True
     >>> (x.field_strength, x.sweat) == (1, 0)
     True
     >>> x[0] is x.point
     True
     >>> [x.field_strength, x.sweat] == x[1:]
     True
     >>> x is MetaballCtrlPoint(x)
     True
     >>> y = MetaballCtrlPoint(x, copy=True)
     >>> x is y
     False
     >>> x.is_same(y)
     True
     >>> x.is_same(MetaballCtrlPoint((0, 0, 1), 1, 0))
     True
     >>> x.is_same(MetaballCtrlPoint(point=(0, 0, 1), field_strength=1, sweat=0))
     True
     >>> x.is_same(MetaballCtrlPoint([(0, 0, 1), 1, 0]))
     True
     >>> x.is_same(MetaballCtrlPoint(("0, 0, 1", 1, 0)))
     True
     """
     types.ListType, types.TupleType
     if isinstance(point, MetaballCtrlPoint):
         if copy:
             return MetaballCtrlPoint(*point, copy=True)
         else:
             return point
     result = collections.Sequence.__new__(cls)
     is_non_string_sequence = isinstance(
         point, collections.Sequence) and not isinstance(point, str)
     if is_non_string_sequence and len(point) == 3 and isinstance(
             point[0],
         (types.ListType, types.TupleType, types.StringType, Vector)):
         # this means the parameters were wrapped in a sequence, so we unwrap them
         point, field_strength, sweat = point
     result.items = [
         Vector(point, copy=copy),
         float(field_strength),
         float(sweat)
     ]
     return result
예제 #27
0
 def __init__(self, name, base=(0, 0, 0), height=(0, 0, 1),
              a=(0, 1, 0), b=(0.5, 0, 0), c=(0, 0.5, 0), d=(1, 0, 0),
              copy=False):
     Primitive.__init__(self, name=name)
     self.base = Vector(base, copy=copy)
     self.height = Vector(height, copy=copy)
     self.a = Vector(a, copy=copy)
     self.b = Vector(b, copy=copy)
     self.c = Vector(c, copy=copy)
     self.d = Vector(d, copy=copy)
예제 #28
0
 def __new__(cls,
             name,
             base=(0, 0, 0),
             n=(0, 0, 1),
             h=1,
             r_base=1,
             r_top=0.5,
             copy=False):
     return TGC(name=name,
                base=base,
                height=Vector(n, copy=True) * h,
                a=(0, -r_base, 0),
                b=(r_base, 0, 0),
                c=(0, -r_top, 0),
                d=(r_top, 0, 0),
                copy=copy)
예제 #29
0
 def angle_between_vectors(v1, v2):
     """
     Calculates the angle between <v1> and <v2>. The result is in the range [0, pi]
     On degenerate input (any of the vectors of norm 0) will raise ValueError.
     """
     v1 = Vector(v1, copy=False)
     v2 = Vector(v2, copy=False)
     n1 = v1.norm()
     n2 = v2.norm()
     if n1 == 0 or n2 == 0:
         raise ValueError("Can't calculate angle between zero length vectors !")
     cos_a = v1.dot(v2) / (n1 * n2)
     cos_a = max(-1.0, min(1.0, cos_a))
     return math.acos(cos_a)
예제 #30
0
 def __new__(cls, point, d_outer=0.5, d_inner=0.3, r_bend=1, copy=False):
     """
     Parse a PipePoint from multiple possible inputs:
     >>> x = PipePoint("0, 1, 2", 3, 2, 5)
     >>> x.point.is_same((0, 1, 2))
     True
     >>> (x.d_outer, x.d_inner, x.r_bend) == (3, 2, 5)
     True
     >>> x[0] is x.point
     True
     >>> [x.d_outer, x.d_inner, x.r_bend] == x[1:]
     True
     >>> x is PipePoint(x)
     True
     >>> y = PipePoint(x, copy=True)
     >>> x is y
     False
     >>> x.is_same(y)
     True
     >>> x.is_same(PipePoint((0, 1, 2), 3, 2, 5))
     True
     >>> x.is_same(PipePoint(point=(0, 1, 2), d_inner=2, d_outer=3, r_bend=5))
     True
     >>> x.is_same(PipePoint([(0, 1, 2), 3, 2, 5]))
     True
     >>> x.is_same(PipePoint(("0, 1, 2", 3, 2, 5)))
     True
     """
     if isinstance(point, PipePoint):
         if copy:
             return PipePoint(*point, copy=True)
         else:
             return point
     result = collections.Sequence.__new__(cls)
     is_non_string_sequence = isinstance(
         point, collections.Sequence) and not isinstance(point, str)
     if is_non_string_sequence and len(point) == 4:
         # this means the parameters were wrapped in a sequence, so we unwrap them
         point, d_outer, d_inner, r_bend = point
     result.items = [
         Vector(point, copy=copy),
         float(d_outer),
         float(d_inner),
         float(r_bend)
     ]
     return result
예제 #31
0
    def from_wdb(name, data):
        points=[]
        points_head = data.metaball_ctrl_head.forw
        crt_head = points_head
        while(1):
            crt_point = ctypes.cast(crt_head, ctypes.POINTER(librt.wdb_metaballpt)).contents
            crt_head = crt_point.l.forw
            points.append((
                Vector(crt_point.coord), crt_point.fldstr, crt_point.sweat
            ))
            if ctypes.addressof(points_head) == ctypes.addressof(crt_head):
                points[-1:] = []
                break

        return Metaball(
            name=name,
            threshold=data.threshold,
            method=data.method,
            points=points,
            copy=False,
        )
예제 #32
0
 def __init__(
     self,
     name,
     file_name,
     x_dim=1,
     y_dim=1,
     z_dim=1,
     low_thresh=0,
     high_thresh=128,
     cell_size=(1, 1, 1),
     mat=Transform.unit(),
     copy=False,
 ):
     Primitive.__init__(self, name=name)
     if not os.path.isfile(file_name):
         raise ValueError("File {} does not exist !".format(file_name))
     self.file_name = file_name
     self.x_dim = x_dim
     self.y_dim = y_dim
     self.z_dim = z_dim
     self.low_thresh = low_thresh
     self.high_thresh = high_thresh
     self.cell_size = Vector(cell_size, copy=copy)
     self.mat = Transform(mat, copy=copy, force=True)
예제 #33
0
class VOL(Primitive):
    def __init__(
        self,
        name,
        file_name,
        x_dim=1,
        y_dim=1,
        z_dim=1,
        low_thresh=0,
        high_thresh=128,
        cell_size=(1, 1, 1),
        mat=Transform.unit(),
        copy=False,
    ):
        Primitive.__init__(self, name=name)
        if not os.path.isfile(file_name):
            raise ValueError("File {} does not exist !".format(file_name))
        self.file_name = file_name
        self.x_dim = x_dim
        self.y_dim = y_dim
        self.z_dim = z_dim
        self.low_thresh = low_thresh
        self.high_thresh = high_thresh
        self.cell_size = Vector(cell_size, copy=copy)
        self.mat = Transform(mat, copy=copy, force=True)

    def __repr__(self):
        result = (
            "{}({}, file_name={}, x_dim={}, y_dim={}, z_dim={}, " "low_thresh={}, high_thresh={} cell_size={}, mat={})"
        )
        return result.format(
            self.__class__.__name__,
            self.file_name,
            self.name,
            self.x_dim,
            self.y_dim,
            self.z_dim,
            self.low_thresh,
            self.high_thresh,
            repr(self.cell_size),
            repr(self.mat),
        )

    def update_params(self, params):
        params.update(
            {
                "file_name": self.file_name,
                "x_dim": self.x_dim,
                "y_dim": self.y_dim,
                "z_dim": self.z_dim,
                "low_thresh": self.low_thresh,
                "high_thresh": self.high_thresh,
                "cell_size": self.cell_size,
                "mat": self.mat,
            }
        )

    def copy(self):
        return VOL(
            self.name,
            file_name=self.file_name,
            x_dim=self.x_dim,
            y_dim=self.y_dim,
            z_dim=self.z_dim,
            low_thresh=self.low_thresh,
            high_thresh=self.high_thresh,
            cell_size=self.cell_size,
            mat=self.mat,
            copy=True,
        )

    def has_same_data(self, other):
        if not (
            self.file_name == other.file_name,
            self.x_dim == other.x_dim
            and self.y_dim == other.y_dim
            and self.z_dim == other.z_dim
            and self.low_thresh == other.low_thresh
            and self.high_thresh == other.high_thresh,
        ):
            return False
        return self.cell_size.is_same(other.cell_size) and np.allclose(self.mat, other.mat)

    @staticmethod
    def from_wdb(name, data):
        return VOL(
            name=name,
            file_name=data.file,
            x_dim=data.xdim,
            y_dim=data.ydim,
            z_dim=data.zdim,
            low_thresh=data.lo,
            high_thresh=data.hi,
            cell_size=data.cellsize,
            mat=cta.transform_from_pointer(data.mat),
        )
예제 #34
0
 def __new__(cls, name, base=(0, 0, 0), height=(0, 0, 1), radius=1, copy=False):
     base = Vector(base, copy=copy)
     height = Vector(height, copy=copy)
     a = height.construct_normal()
     b = a.cross(height)
     return TGC(name=name, base=base, height=height, a=a, b=b, c=a, d=b, copy=False)
예제 #35
0
 def __init__(self, name, center, a, b, c, copy=False):
     Primitive.__init__(self, name=name)
     self.center = Vector(center, copy=copy)
     self.a = Vector(a, copy=copy)
     self.b = Vector(b, copy=copy)
     self.c = Vector(c, copy=copy)
예제 #36
0
 def check_arb(self, name, expected_points):
     shape = self.lookup_shape(name)
     expected = Vector(expected_points)
     if not expected.is_same(shape.points):
         self.fail("{0} != {1}".format(expected, shape.points))
예제 #37
0
 def test_arbn_defaults(self):
     shape = self.lookup_shape("arbn.s")
     expected = Vector((1, 0, 0, 1, -1, 0, 0, 1, 0, 1, 0, 1, 0, -1, 0, 1, 0, 0, 1, 1, 0, 0, -1, 1))
     self.assertTrue(expected.is_same(cta.flatten_numbers(shape.planes)))
예제 #38
0
 def check_tgc(self, name, expected_points):
     shape = self.lookup_shape(name)
     expected = Vector(expected_points)
     actual = cta.flatten_numbers([shape.base, shape.height, shape.a, shape.b, shape.c, shape.d])
     if not expected.is_same(actual):
         self.fail("{0} != {1}".format(expected, actual))
예제 #39
0
 def __init__(self, name, center=(0, 0, 0), normal=(1, 0, 0), magnitude=1, copy=False):
     Primitive.__init__(self, name=name)
     self.center = Vector(center, copy=copy)
     self.normal = Vector(normal, copy=copy)
     self.magnitude = magnitude
예제 #40
0
class Ellipsoid(Primitive):

    def __init__(self, name, center, a, b, c, copy=False):
        Primitive.__init__(self, name=name)
        self.center = Vector(center, copy=copy)
        self.a = Vector(a, copy=copy)
        self.b = Vector(b, copy=copy)
        self.c = Vector(c, copy=copy)

    def __repr__(self):
        return "ELL(name={0}, center={1}, a={2}, b={3}, c={4})".format(
            self.name, repr(self.center), repr(self.a), repr(self.b), repr(self.c)
        )

    def __iter__(self):
        yield self.center
        yield self.a
        yield self.b
        yield self.c

    def update_params(self, params):
        params.update({
            "center": self.center,
            "a": self.a,
            "b": self.b,
            "c": self.c,
        })

    def copy(self):
        return Ellipsoid(self.name, self.center, self.a, self.b, self.c, copy=True)

    def has_same_data(self, other):
        return all(map(Vector.is_same, self, other))

    def _get_radius(self):
        """
        Returns the radius if this is a Sphere, None otherwise.
        Can also be used as a test if this is a sphere:
        >>> x = Ellipsoid("test", "0, 0, 0", (10, 0, 0), [0, 10, 0], Vector("0, 0, 10"))
        >>> x.radius
        10.0
        >>> x.a = Vector("1, 0, 0")
        >>> x.radius is None
        True
        """
        mag_a = self.a.norm()
        mag_b = self.b.norm()
        mag_c = self.c.norm()
        if np.allclose((mag_a, mag_b), (mag_b, mag_c)):
            return mag_a
        else:
            return None

    radius = property(_get_radius)

    @staticmethod
    def from_wdb(name, data):
        return Ellipsoid(
            name=name,
            center=data.v,
            a=data.a,
            b=data.b,
            c=data.c,
        )