Returns a copy of the plane, rotated by t radians about the given line See notes on Line#rotate.
962033
function(t, line$$1) {
                var R = t.determinant ? t.elements : matrix$2.Rotation(t, line$$1.direction).elements;
                var C = line$$1.pointClosestTo(this.anchor).elements;
                var A = this.anchor.elements, N = this.normal.elements;
                var C1 = C[0], C2 = C[1], C3 = C[2], A1 = A[0], A2 = A[1], A3 = A[2];
                var x = A1 - C1, y = A2 - C2, z = A3 - C3;
                return Plane$1.create([
                  C1 + R[0][0] * x + R[0][1] * y + R[0][2] * z,
                  C2 + R[1][0] * x + R[1][1] * y + R[1][2] * z,
                  C3 + R[2][0] * x + R[2][1] * y + R[2][2] * z
                ], [
                  R[0][0] * N[0] + R[0][1] * N[1] + R[0][2] * N[2],
                  R[1][0] * N[0] + R[1][1] * N[1] + R[1][2] * N[2],
                  R[2][0] * N[0] + R[2][1] * N[1] + R[2][2] * N[2]
                ]);
              }
1187861
def lat_id(self, line):
        ''' 
        '''
        if self.grid == 'WAC':
            lat = ((1 + self.LINE_PROJECTION_OFFSET - line) *
                   self.MAP_SCALE * 1e-3 / self.A_AXIS_RADIUS)
            return lat * 180 / np.pi
        else:
            lat = float(self.CENTER_LATITUDE) - \
                (line - float(self.LINE_PROJECTION_OFFSET) - 1)\
                / float(self.MAP_RESOLUTION)
            return lat
536189
function(plane) {
        vec3.copy(this.normal.array, plane.normal.array);
        this.normal._dirty = true;
        this.distance = plane.distance;
    }
1157282
def copy(self):
        
        chart = Chart.__new__(Chart)
        chart.date = self.date
        chart.pos = self.pos
        chart.hsys = self.hsys
        chart.objects = self.objects.copy()
        chart.houses = self.houses.copy()
        chart.angles = self.angles.copy()
        return chart
119006
public static Geometry rotate(Geometry geom, double theta) {
        if (geom != null) {
            Coordinate center = geom.getEnvelopeInternal().centre();
            return rotate(geom, theta, center.x, center.y);
        } else {
            return null;
        }
    }
1253873
def rotate(curve, degs, origin=None):
    
    def transform(z):
        return exp(1j*radians(degs))*(z - origin) + origin

    if origin is None:
        if isinstance(curve, Arc):
            origin = curve.center
        else:
            origin = curve.point(0.5)

    if isinstance(curve, Path):
        return Path(*[rotate(seg, degs, origin=origin) for seg in curve])
    elif is_bezier_segment(curve):
        return bpoints2bezier([transform(bpt) for bpt in curve.bpoints()])
    elif isinstance(curve, Arc):
        new_start = transform(curve.start)
        new_end = transform(curve.end)
        new_rotation = curve.rotation + degs
        return Arc(new_start, radius=curve.radius, rotation=new_rotation,
                   large_arc=curve.large_arc, sweep=curve.sweep, end=new_end)
    else:
        raise TypeError("Input `curve` should be a Path, Line, "
                        "QuadraticBezier, CubicBezier, or Arc object.")
250863
private static void getLinealGeometry(ArrayList<LineString> lines, Geometry geometry) {
         for (int i = 0; i < geometry.getNumGeometries(); i++) {
            Geometry subGeom = geometry.getGeometryN(i);
            if(subGeom instanceof LineString){
                lines.add((LineString) subGeom);
            }
            else if (subGeom instanceof GeometryCollection){
                getLinealGeometry(lines, subGeom);
            }
        }
    }
100597
function(obj) {
                if (obj.normal) {
                  // obj is a plane
                  var V = this.line.intersectionWith(obj);
                  if (V === null) { return null; }
                  return this.pointClosestTo(V);
                } else {
                  // obj is a line (segment) or point
                  var P = this.line.pointClosestTo(obj);
                  if (P === null) { return null; }
                  if (this.contains(P)) { return P; }
                  return (this.line.positionOf(P) < 0 ? this.start : this.end).dup();
                }
              }
207247
def _rotate(pair, step):
        
        step = Step(step)
        movement = {
            "U": "RFLB", 
            "D": "LFRB", 
            "R": "FUBD", 
            "L": "FDBU", 
            "F": "URDL", 
            "B": "ULDR", 
            }[step.face]
        movement = {
            movement[i]: movement[(i + step.is_clockwise + (-1 * step.is_counter_clockwise) + (2 * step.is_180)) % 4]
            for i in range(4)
            }
        for cubie in pair:
            if step.face not in cubie:
                if cubie.type == "edge":
                    result_edge = cubie.copy()
                else:
                    result_corner = cubie.copy()
            else:
                result = {}
                for face, square in cubie:
                    if face not in movement:
                        result[face] = square
                    else:
                        result[movement[face]] = square
                if len(result) == 2:
                    result_edge = Edge(**result)
                else:
                    result_corner = Corner(**result)
        return (result_corner, result_edge)
1244216
private static Point getLinesIntersection(Line2D a,
                                              Line2D b) {
        double d = (a.getX1() - a.getX2()) * (b.getY2() - b.getY1()) - (a.getY1() - a.getY2()) * (b.getX2() - b.getX1());
        double da = (a.getX1() - b.getX1()) * (b.getY2() - b.getY1()) - (a.getY1() - b.getY1()) * (b.getX2() - b.getX1());
        double ta = da / d;
        Point p = new Point();
        p.setLocation(a.getX1() + ta * (a.getX2() - a.getX1()),
                      a.getY1() + ta * (a.getY2() - a.getY1()));
        return p;
    }
442076
def copy(self):
        """"""
        o = self.__class__(self.project, self.name)
        Scriptable.copy(self, o)
        o.position = tuple(self.position)
        o.direction = self.direction
        o.rotation_style = self.rotation_style
        o.size = self.size
        o.is_draggable = self.is_draggable
        o.is_visible = self.is_visible
        return o
837688
def plane
      # Such a change is only possible if the Slice instance has a Contour with at least three Coordinates:
      raise "This Slice does not contain a Contour. Plane determination is not possible." if @contours.length == 0
      raise "This Slice does not contain a Contour with at least 3 Coordinates. Plane determination is not possible." if @contours.first.coordinates.length < 3
      # Get three coordinates from our Contour:
      contour = @contours.first
      num_coords = contour.coordinates.length
      c1 = contour.coordinates.first
      c2 = contour.coordinates[num_coords / 3]
      c3 = contour.coordinates[2 * num_coords / 3]
      return Plane.calculate(c1, c2, c3)
    end
98749
def copy(self):
        
        dup = type(self)()
        dup._indices = OrderedDict(
            (k, list(v)) for k,v in six.iteritems(self._indices)
        )
        dup._lines = self._lines.copy()
        return dup
817776
def copy(self):
        
        return self.__class__(self.x, self.y, *self._args, **self._kwargs)
1275837
def copy(self):
        
        c = matrix()
        c.tt = self.tt.copy()
        c.n = self.n.copy()
        c.m = self.m.copy()
        return c
364444
public DashedVerticalLine dashedVerticalLineInstance() {
           LineObject lineObject = new LineObject();
           DashedVerticalLine dashedVerticalLine = lineObject.dashedVerticalLineInstance();
		objectsInstance().add(lineObject);
		return dashedVerticalLine;
	}
294722
def _generate_plane(normal, origin):
    
    plane = vtk.vtkPlane()
    plane.SetNormal(normal[0], normal[1], normal[2])
    plane.SetOrigin(origin[0], origin[1], origin[2])
    return plane