# -*- coding: utf-8 -*-
############################################################################
#
# Copyright (C) 2008-2015
# Christian Kohlöffel
# Vinzenz Schulz
# Jean-Paul Schouwstra
#
# This file is part of DXF2GCODE.
#
# DXF2GCODE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# DXF2GCODE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with DXF2GCODE. If not, see .
#
############################################################################
from __future__ import absolute_import
from __future__ import division
from math import pi, sqrt, sin, cos
from copy import deepcopy
import logging
from core.linegeo import LineGeo
from core.arcgeo import ArcGeo
from core.point import Point
from core.shape import Geos
from core.shape import Shape
logger = logging.getLogger('core.shapeoffset')
eps = 1e-9
class offShapeClass(Shape):
"""
This Class is used to generate The fofset aof a shape according to:
"A pair-wise offset Algorithm for 2D point sequence curve"
http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.101.8855
"""
def __init__(self, parent=None, offset=1, offtype='in'):
"""
Standard method to initialize the class
@param closed: Gives information about the shape, when it is closed
this value becomes 1. Closed means it is a Polygon, otherwise it is a
Polyline
@param length: The total length of the shape including all geometries
@param geos: The list with all geometries included in the shape. May
also contain arcs. These will be reflected by multiple lines in order
to easy calclations.
"""
super(offShapeClass, self).__init__(nr=parent.nr,
closed=parent.closed,
geos=[])
self.offset = offset
self.offtype = offtype
self.segments = []
self.rawoff = []
self.geos_preprocessing(parent)
self.make_segment_types()
nextConvexPoint = [
e for e in self.segments if isinstance(e, ConvexPoint)]
# logger.debug(nextConvexPoint)
# nextConvexPoint=[nextConvexPoint[31]]
self.counter = 0
while len(nextConvexPoint): # [self.convex_vertex[-1]]:
convex_vertex_nr = self.segments.index(nextConvexPoint[0])
forward, backward = self.PairWiseInterferenceDetection(
convex_vertex_nr + 1, convex_vertex_nr - 1)
if forward is None:
return
break
if (backward == 0 and
forward == (len(self.segments) - 1) and
self.closed):
self.segments = []
break
# Make Raw offset curve of forward and backward segment
fw_rawoff_seg = self.make_rawoff_seg(self.segments[forward])
bw_rawoff_seg = self.make_rawoff_seg(self.segments[backward])
# Intersect the two segements
iPoint = fw_rawoff_seg.find_inter_point(bw_rawoff_seg, typ="TIP")
if iPoint is None:
logger.debug("fw_rawoff_seg: %s, bw_rawoff_seg: %s" %
(fw_rawoff_seg, bw_rawoff_seg))
logger.debug("forward: %s, backward: %s, iPoint: %s" % (
forward, backward, iPoint))
logger.error("No intersection found?!")
self.segments = []
# raise Exception("No intersection found?!")
break
# Reomve the LIR from the PS Curce
self.remove_LIR(forward, backward, iPoint)
nextConvexPoint = [
e for e in self.segments if isinstance(e, ConvexPoint)]
# logger.debug(nextConvexPoint)
# nextConvexPoint=[]
# logger.debug(nextConvexPoint)
for seg in self.segments:
self.rawoff += [self.make_rawoff_seg(seg)]
def __str__(self):
"""
Standard method to print the object
@return: A string
"""
return "\nnr: %i" % self.nr +\
"\nclosed: %s" % self.closed +\
"\ngeos: %s" % self.geos +\
"\nofftype: %s" % self.offtype +\
"\noffset: %s" % self.offset +\
"\nsegments: %s" % self.segments +\
"\nrawoff %s" % self.rawoff
def geos_preprocessing(self, parent):
"""
Do all the preprocessing required in order to have working offset
algorithm.
@param parent: The parent shape including the geometries to
be offsetted.
"""
self.geos = Geos([])
if self.closed:
last_Pe = parent.geos[-1].Pe.rot_sca_abs(parent=parent.parentEntity)
else:
last_Pe = None
for geo in parent.geos:
if isinstance(geo, LineGeo):
new_geo = OffLineGeo(geo=geo, parent=parent.parentEntity)
elif isinstance(geo, ArcGeo):
new_geo = OffArcGeo(geo=geo, parent=parent.parentEntity)
else:
logger.error("Should not be here")
if last_Pe is not None:
# logger.debug("Current distance: %s" %
# new_geo.Ps.distance(last_Pe))
if new_geo.Ps.distance(last_Pe) > 0.0:
new_geo.match_Ps_to_Pe(last_Pe)
# logger.debug("New distance: %s" %
# new_geo.Ps.distance(last_Pe))
last_Pe = new_geo.Pe
self.geos.append(new_geo)
self.make_shape_ccw()
self.join_colinear_lines()
def make_segment_types(self):
"""
This function is called in order to generate the segements according
to Definiton 2.
An edge (line) is a linear segment and a reflex vertex is is reflex
segment. Colinear lines are assumed to be removed prior to the segment
type definition.
"""
# Do only if more then 2 geometies
# if len(self.geos) < 2:
# return
# Start with first Vertex if the line is closed
if self.closed:
start = 0
else:
start = 1
geo1 = self.geos[0]
if isinstance(geo1, LineGeo):
geo1.start_normal = geo1.Ps.get_normal_vector(geo1.Pe)
geo1.end_normal = geo1.Ps.get_normal_vector(geo1.Pe)
else:
geo1.start_normal = geo1.O.unit_vector(geo1.Ps, r=1)
geo1.end_normal = geo1.O.unit_vector(geo1.Pe, r=1)
if geo1.ext < 0:
geo1.start_normal = geo1.start_normal * -1
geo1.end_normal = geo1.end_normal * -1
self.segments += [geo1]
for i in range(start, len(self.geos)):
geo1 = self.geos[i - 1]
geo2 = self.geos[i]
if i == start:
if isinstance(geo1, LineGeo):
geo1.start_normal = geo1.Ps.get_normal_vector(geo1.Pe)
geo1.end_normal = geo1.Ps.get_normal_vector(geo1.Pe)
else:
geo1.start_normal = geo1.O.unit_vector(geo1.Ps, r=1)
geo1.end_normal = geo1.O.unit_vector(geo1.Pe, r=1)
if geo1.ext < 0:
geo1.start_normal = geo1.start_normal * -1
geo1.end_normal = geo1.end_normal * -1
if isinstance(geo2, LineGeo):
geo2.start_normal = geo2.Ps.get_normal_vector(geo2.Pe)
geo2.end_normal = geo2.Ps.get_normal_vector(geo2.Pe)
elif isinstance(geo2, ArcGeo):
geo2.start_normal = geo2.O.unit_vector(geo2.Ps, r=1)
geo2.end_normal = geo2.O.unit_vector(geo2.Pe, r=1)
if geo2.ext < 0:
geo2.start_normal = geo2.start_normal * -1
geo2.end_normal = geo2.end_normal * -1
if ((isinstance(geo2, ArcGeo)) and
((self.offtype == "out" and geo2.ext > 0) or
(self.offtype == "in" and geo2.ext < 0)) and
((geo2.r - abs(self.offset)) < -eps)):
newgeo2 = ConvexPoint(geo2.O.x, geo2.O.y)
newgeo2.start_normal = geo2.start_normal
newgeo2.end_normal = geo2.end_normal
geo2 = newgeo2
if (((geo1.Pe.ccw(geo1.Pe + geo1.end_normal,
geo1.Pe + geo1.end_normal +
geo2.start_normal) == 1) and
self.offtype == "in") or
(geo1.Pe.ccw(geo1.Pe + geo1.end_normal,
geo1.Pe + geo1.end_normal +
geo2.start_normal) == -1 and
self.offtype == "out")):
reflexPe = OffPoint(x=geo1.Pe.x, y=geo1.Pe.y)
reflexPe.start_normal = geo1.end_normal
reflexPe.end_normal = geo2.start_normal
self.segments += [reflexPe, geo2]
elif (geo1.Pe.ccw(geo1.Pe + geo1.end_normal,
geo1.Pe + geo1.end_normal +
geo2.start_normal) == 0):
self.segments += [geo2]
# Add the linear segment which is a line connecting 2 vertices
else:
self.segments += [ConvexPoint(geo1.Pe.x, geo1.Pe.y), geo2]
def make_rawoff_seg(self, seg):
"""
This function returns the rawoffset of a segement. A line for a line
and a circle for a reflex segement.
@param segment_nr: The nr of the segement for which the rawoffset
segement shall be generated
@ return: Returns the rawoffsetsegement of the defined segment
"""
# seg=self.segments[segment_nr]
if self.offtype == "out":
offset = -abs(self.offset)
else:
offset = abs(self.offset)
# if segement 1 is inverted change End Point
if isinstance(seg, OffLineGeo):
Ps = seg.Ps + seg.start_normal * offset
Pe = seg.Pe + seg.end_normal * offset
return OffLineGeo(Ps, Pe)
elif isinstance(seg, OffPoint):
Ps = seg + seg.start_normal * offset
Pe = seg + seg.end_normal * offset
return OffArcGeo(Ps=Ps, Pe=Pe, O=deepcopy(seg),
r=self.offset, direction=offset)
elif isinstance(seg, OffArcGeo):
Ps = seg.Ps + seg.start_normal * offset
Pe = seg.Pe + seg.end_normal * offset
logger.debug(seg.Ps)
logger.debug(seg.Pe)
logger.debug(seg.start_normal)
logger.debug(seg.end_normal)
if seg.ext > 0:
return OffArcGeo(Ps=Ps, Pe=Pe, O=seg.O,
r=seg.r + offset, direction=seg.ext)
else:
return OffArcGeo(Ps=Ps, Pe=Pe, O=seg.O,
r=seg.r - offset, direction=seg.ext)
elif isinstance(seg, ConvexPoint):
Ps = seg + seg.start_normal * offset
Pe = seg + seg.end_normal * offset
return OffArcGeo(Ps=Ps, Pe=Pe, O=deepcopy(seg),
r=self.offset, direction=offset)
else:
logger.error("Unsupportet Object type: %s" % type(seg))
def interfering_full(self, segment1, direction, segment2):
"""
Check if the Endpoint (dependent on direction) of segment 1 is
interfering with segment 2 Definition according to Definition 6
@param segment 1: The first segment
@param direction: The direction of the line 1, as given -1 reversed
@param segment 2: The second segment to be checked
@ return: Returns True or False
"""
# if isinstance(segment1, ConvexPoint):
# logger.debug("Should not be here")
# return False
# else:
# offGeo = self.make_rawoff_seg(segment1)
# self.interferingshapes += [offGeo]
#
# if isinstance(segment1, OffPoint):
# offGeo = segment1
# elif direction == 1:
# offGeo = segment1.Pe
# elif direction == -1:
# offGeo = segment1.Ps
# #
# logger.debug(offGeo)
# logger.debug("Full distance: %s" % segment2.distance(offGeo))
# If the distance from the Line to the Center of the Tangential Circle
# is smaller then the radius we have an intersection
# return segment2.distance(offGeo) <= abs(self.offset) + eps
# if segement 1 is inverted change End Point
if isinstance(segment1, OffLineGeo) and direction == 1:
Pe = segment1.Pe
elif isinstance(segment1, OffLineGeo) and direction == -1:
Pe = segment1.Ps
elif isinstance(segment1, ConvexPoint):
return False
elif isinstance(segment1, OffPoint):
Pe = segment1
elif isinstance(segment1, OffArcGeo) and direction == 1:
Pe = segment1.Pe
elif isinstance(segment1, OffArcGeo) and direction == -1:
Pe = segment1.Ps
else:
logger.error("Unsupportet Object type: %s" % type(segment1))
# if we cut outside reverse the offset
if self.offtype == "out":
offset = -abs(self.offset)
else:
offset = abs(self.offset)
if direction == 1:
distance = segment2.distance(Pe + segment1.end_normal * offset)
else:
distance = segment2.distance(Pe + segment1.start_normal * offset)
# logger.debug("Full distance: %s" % distance)
# If the distance from the Segment to the Center of the Tangential
# Circle is smaller then the radius we have an intersection
return distance <= abs(offset) + eps
def interfering_partly(self, segment1, direction, segment2):
"""
Check if any tangential circle of segment 1 is interfering with
segment 2. Definition according to Definition 5
@param segment 1: The first Line
@param direction: The direction of the segment 1, as given -1 reversed
@param segment 2: The second line to be checked
@ return: Returns True or False
"""
if isinstance(segment1, ConvexPoint):
logger.debug("Should not be here")
logger.debug(segment1)
return False
#offGeo = self.make_rawoff_seg(segment1)
else:
offGeo = self.make_rawoff_seg(segment1)
#
# logger.debug(offGeo)
# logger.debug("Partly distance: %s" % segment2.distance(offGeo))
# If the distance from the Line to the Center of the Tangential Circle
# is smaller then the radius we have an intersection
return segment2.distance(offGeo) <= abs(self.offset) + eps
def Interfering_relation(self, segment1, segment2):
"""
Check the interfering relation between two segements (segment1 and
segment2). Definition acccording to Definition 6
@param segment1: The first segment (forward)
@param segment2: The second segment (backward)
@return: Returns one of [full, partial, reverse, None] interfering
relations for both segments
"""
# Check if segments are equal
if segment1 == segment2:
return None, None
if self.interfering_full(segment1, 1, segment2):
L1_status = "full"
elif self.interfering_partly(segment1, 1, segment2):
L1_status = "partial"
else:
L1_status = "reverse"
if self.interfering_full(segment2, -1, segment1):
L2_status = "full"
elif self.interfering_partly(segment2, -1, segment1):
L2_status = "partial"
else:
L2_status = "reverse"
# logger.debug("Start Status: L1_status: %s,L2_status: %s"
# % (L1_status, L2_status))
return [L1_status, L2_status]
def PairWiseInterferenceDetection(self, forward, backward,):
"""
Returns the first forward and backward segment nr. for which both
interfering conditions are partly.
@param foward: The nr of the first forward segment
@param backward: the nr. of the first backward segment
@return: forward, backward
"""
val = 2000
# self.counter = 0
L1_status, L2_status = "full", "full"
# Repeat until we reached the Partial-interfering-relation
while not(L1_status == "partial" and L2_status == "partial"):
self.interferingshapes = []
self.counter += 1
if forward >= len(self.segments):
forward = 0
segment1 = self.segments[forward]
segment2 = self.segments[backward]
# logger.debug("segment1: %s" % segment1)
# logger.debug("segment2: %s" % segment2)
if isinstance(segment1, ConvexPoint):
forward += 1
if forward >= len(self.segments):
forward = 0
segment1 = self.segments[forward]
# logger.debug("Forward ConvexPoint")
if isinstance(segment2, ConvexPoint):
backward -= 1
segment2 = self.segments[backward]
[L1_status, L2_status] = self.Interfering_relation(
segment1, segment2)
# logger.debug("Start Status: L1_status: %s,L2_status: %s"
# % (L1_status, L2_status))
"""
The reverse interfering segment is replaced by the first
non-reverse-interfering segment along it's tracking direction
"""
if L1_status == "reverse":
while L1_status == "reverse":
self.counter += 1
# logger.debug(self.counter)
if self.counter > val:
break
if self.counter >= val:
self.interferingshapes = []
forward += 1
if forward >= len(self.segments):
forward = 0
segment1 = self.segments[forward]
if isinstance(segment1, ConvexPoint):
forward += 1
segment1 = self.segments[forward]
# logger.debug("Forward ConvexPoint")
# logger.debug("Reverse Replace: forward: %s, backward: %s"
# % (forward, backward))
[L1_status, L2_status] = self.Interfering_relation(
segment1, segment2)
# logger.debug("Checking: forward: %s, backward: %s"
# %(forward, backward))
# logger.debug("Replace Rev.: L1_status: %s,L2_status: %s"
# %(L1_status,L2_status))
elif L2_status == "reverse":
while L2_status == "reverse":
self.counter += 1
# logger.debug(self.counter)
if self.counter > val:
break
if self.counter >= val:
self.interferingshapes = []
backward -= 1
# logger.debug("Reverse Replace: forward: %s, backward: %s"
# % (forward, backward))
segment2 = self.segments[backward]
if isinstance(segment2, ConvexPoint):
backward -= 1
segment2 = self.segments[backward]
# logger.debug("Backward ConvexPoint")
[L1_status, L2_status] = self.Interfering_relation(
segment1, segment2)
# logger.debug("Checking: forward: %s, backward: %s"
# % (forward, backward))
# logger.debug("Replace Rev.: L1_status: %s,L2_status: %s"
# % (L1_status, L2_status))
"""
Full interfering segment is replaced by the nexst segemnt along the
tracking direction.
"""
if L1_status == "full" and (L2_status == "partial" or
L2_status == "full"):
forward += 1
elif L2_status == "full" and (L1_status == "partial" or
L1_status == "partial"):
backward -= 1
# If The begin end point is the end end point we are done.
if L1_status is None and L2_status is None:
# logger.debug("Begin = End; Remove all")
return len(self.segments) - 1, 0
# logger.debug(self.counter)
# logger.debug("L1_status: %s,L2_status:
# %s" %(L1_status,L2_status))
if self.counter == val:
self.interferingshapes = []
if self.counter > val: # 26:
logger.error("No partial - partial status found")
return None, None
# logger.debug("Result: forward: %s, backward: %s"
# %(forward, backward))
return forward, backward
def remove_LIR(self, forward, backward, iPoint):
"""
The instance is used to remove the LIR from the PS curve.
@param forward: The forward segment of the LIR
@param backward: The backward segement of the LIR
@param iPoint: The Intersection point of the LIR
"""
if backward > forward:
pop_range = self.segments[backward + 1:len(self.segments)]
pop_range += self.segments[0:forward]
elif backward < 0:
pop_range = self.segments[
len(self.segments) + backward + 1:len(self.segments)]
pop_range += self.segments[0:forward]
else:
pop_range = self.segments[backward + 1:forward]
if self.offtype == "out":
rev = True
else:
rev = False
# Modify the first segment and the last segment of the LIR
self.segments[forward] = self.segments[
forward].trim(Point=iPoint, dir=1, rev_norm=rev)
self.segments[backward] = self.segments[
backward].trim(Point=iPoint, dir=-1, rev_norm=rev)
# Remove the segments which are inbetween the LIR
self.segments = [x for x in self.segments if x not in pop_range]
class SweepLine:
def __init__(self, geos=[], closed=True):
"""
The init function of the SweepLine Class. It is calling a sweep line
algorithm in order to find all intersection of the given geometries
@param geos: A list if with geometries in their ordered structure.
@param closed: If the geometries are closed (Polyline or Polygon)
"""
self.geos = []
self.closed = closed
self.sweep_array = []
self.intersections = []
self.add_to_sweep_array(geos, self.closed)
def __str__(self):
"""
Standard method to print the object
@return: A string
"""
sweep_array_order = []
for element in self.sweep_array:
add_array = []
rem_array = []
swoop_array = []
for add_ele in element.add:
add_array.append(add_ele.nr)
for rem_ele in element.remove:
rem_array.append(rem_ele.nr)
for swoop_ele in element.swoop:
swoop_array.append(swoop_ele)
sweep_array_order += [[element.Point.x,
element.Point.y],
add_array,
rem_array,
swoop_array]
return ('\nlen(geos): %i' % len(self.geos)) + \
('\nclosed: %i' % self.closed) + \
('\ngeos: %s' % self.geos) + \
('\nsweep_array_order: %s' % sweep_array_order)
def add_to_sweep_array(self, geos=[], closed=True):
"""
This instance adds the given geometries to the sweep array.
If there are already some defined it will just continue to
add them. This may be used to get the intersection of two shapes
@param: the geometries to be added
@param: if these geometries are closed shape or not
"""
sweep_array = []
self.geos += geos
for geo_nr in range(len(geos)):
geo = geos[geo_nr]
geo.iPoints = []
y_val = (geo.BB.Ps.y + geo.BB.Pe.y) / 2
geo.neighbors = []
geo.nr = geo_nr
geo.Point = Point(x=geo.BB.Ps.x, y=y_val)
# Add the neighbors before the geometrie
if geo_nr == 0 and closed:
geo.neighbors.append(geos[geo_nr - 1])
else:
geo.neighbors.append(geos[geo_nr - 1])
# Add the neighbors after the geometrie
if geo_nr == len(geos) - 1 and closed:
geo.neighbors.append(geos[0])
else:
geo.neighbors.append(geos[geo_nr + 1])
y_val = (geo.BB.Ps.y + geo.BB.Pe.y) / 2
sweep_array.append(
SweepElement(Point=geo.Point, add=[geo], remove=[]))
sweep_array.append(
SweepElement(Point=Point(x=geo.BB.Pe.x, y=y_val),
add=[],
remove=[geo]))
# logger.debug(sweep_array)
sweep_array.sort(self.cmp_SweepElement)
# Remove all Points which are there twice
self.sweep_array = [sweep_array[0]]
for ele_nr in range(1, len(sweep_array)):
if abs(self.sweep_array[-1].Point.x -
sweep_array[ele_nr].Point.x) < eps:
self.sweep_array[-1].add += sweep_array[ele_nr].add
self.sweep_array[-1].remove += sweep_array[ele_nr].remove
else:
self.sweep_array.append(sweep_array[ele_nr])
def cmp_asscending_arc(self, P1, P2):
"""
Compare Function for the sorting of Intersection Points on
one common ARC
@param P1: The first Point to be compared
@param P2: The secon Point to be compared
@return: 1 if the distance to the start point of P1 is bigger
"""
# The angle between startpoint and where the intersection occures
d_ang1 = (self.O.norm_angle(P1) - self.s_ang) % (2 * pi)
d_ang2 = (self.O.norm_angle(P2) - self.s_ang) % (2 * pi)
# Correct by 2*pi if the direction is wrong
if self.ext < 0.0:
d_ang1 -= 2 * pi
d_ang2 -= 2 * pi
if d_ang1 > d_ang2:
return 1
elif d_ang1 == d_ang2:
return 0
else:
return -1
def cmp_asscending_line(self, P1, P2):
"""
Compare Function for the sorting of Intersection points on
one common LINE
@param P1: The first Point to be compared
@param P2: The secon Point to be compared
@return: 1 if the distance to the start point of P1 is bigger
"""
d1 = P1.distance(self.Ps)
d2 = P2.distance(self.Ps)
if d1 > d2:
return 1
elif d1 == d2:
return 0
else:
return -1
def cmp_SweepElement(self, ele1, ele2):
"""
Compare Function for the sorting of the sweep array.
@param Point1: First SweepElement point for compare
@param Point2: The second SweepElement point for the compare
@return: True or false whichever is bigger.
"""
if ele1.Point.x < ele2.Point.x:
return -1
elif ele1.Point.x > ele2.Point.x:
return 1
else:
return 0
def cmp_SweepElementy(self, ele1, ele2):
"""
Compare Function for the sorting of the sweep array
just in y direction.
@param ele1: First SweepElement point for compare
@param ele2: The second SweepElement point for the compare
@return: True or false whichever is bigger.
"""
# logger.debug(ele1)
# logger.debug(ele2)
if ele1.Point.y < ele2.Point.y:
return -1
elif ele1.Point.y > ele2.Point.y:
return 1
else:
return 0
def search_intersections(self):
"""
This instance is called to search all intersection
points between the Elements defined in geos
"""
search_array = []
self.found = []
ele_nr = 0
while ele_nr < len(self.sweep_array):
ele = self.sweep_array[ele_nr]
# logger.debug(ele)
ele_nr += 1
for geo in ele.add:
search_array.append(geo)
search_array.sort(self.cmp_SweepElementy)
index = search_array.index(geo)
# logger.debug("add_index: %s" %index)
# logger.debug(index)
# logger.debug(geo)
if len(search_array) >= 2:
if index > 0:
self.search_geo_intersection(
geo, search_array[index - 1])
if index < (len(search_array) - 1):
self.search_geo_intersection(
geo, search_array[index + 1])
for geo in ele.swoop:
# The y values of the elements are exchanged and the upper and
# lower neighbors are checked for intersections
# logger.debug(geo[0].Point)
# logger.debug(geo[1].Point)
# logger.debug(search_array)
y0 = geo[0].Point.y
y1 = geo[1].Point.y
geo[1].Point.y = y0
geo[0].Point.y = y1
# logger.debug(geo[0].Point)
# logger.debug(geo[1].Point)
# logger.debug(search_array)
index0 = search_array.index(geo[0])
index1 = search_array.index(geo[1])
# logger.debug("Pre sort index: %s, %s" %(index0,index1))
search_array.sort(self.cmp_SweepElementy)
index0 = search_array.index(geo[0])
index1 = search_array.index(geo[1])
# logger.debug("Post sort index: %s, %s" %(index0,index1))
min_ind = min(index0, index1)
max_ind = max(index0, index1)
if min_ind > 0:
self.search_geo_intersection(
search_array[min_ind], search_array[min_ind - 1])
if max_ind < (len(search_array) - 1):
self.search_geo_intersection(
search_array[max_ind], search_array[max_ind + 1])
for geo in ele.remove:
index = search_array.index(geo)
# logger.debug("remove_index: %s" %index)
search_array.pop(index)
if len(search_array) >= 2:
if index > 0 and index <= (len(search_array) - 1):
self.search_geo_intersection(
search_array[index - 1], search_array[index])
logger.debug(self.found)
def search_geo_intersection(self, geo1, geo2):
"""
This function is called so search the intersections and to add
the intersection point to the sweep array. This is called during
each search
"""
# logger.debug(search_array[index+1])
# logger.debug("geo1: %s\ngeo2: %s" %(geo1,geo2))
iPoint = (geo1.find_inter_point(geo2))
if (not(iPoint is None) and
not(geo2 in geo1.neighbors)):
iPoint.geo = [geo1, geo2]
# if there is only one instersection
if isinstance(iPoint, Point):
self.found.append(iPoint)
geo1.iPoints += [iPoint]
geo2.iPoints += [iPoint]
self.sweep_array.append(
SweepElement(Point=iPoint,
add=[],
remove=[],
swoop=[[geo1, geo2]]))
else:
self.found += iPoint
geo1.iPoints += iPoint
geo2.iPoints += iPoint
self.sweep_array.append(
SweepElement(Point=iPoint[0],
add=[],
remove=[],
swoop=[[geo1, geo2]]))
self.sweep_array.append(
SweepElement(Point=iPoint[1],
add=[],
remove=[],
swoop=[[geo1, geo2]]))
self.sweep_array.sort(self.cmp_SweepElement)
# logger.debug(self)
class SweepElement:
def __init__(self, Point=Point(0, 0), add=[], remove=[], swoop=[]):
"""
This is the class for each SweepElement given in the sweep_array
@param Point: the Point of the SweepElement (e.g. 2 Points per LineGeo)
@param add: The geometrie to be added
@param remove: The geometrie to be removed
"""
self.Point = Point
self.add = add
self.remove = remove
self.swoop = swoop
def __str__(self):
"""
Standard method to print the object
@return: A string
"""
return ('\nPoint: %s ' % (self.Point)) + \
('\nadd: %s ' % self.add) + \
('\nremove: %s ' % self.remove)
class OffArcGeo(ArcGeo):
"""
Inherited Class for Shapeoffset only. All related offset functions
are concentrated here in orde to keep base classes as clean as possible.
"""
def __init__(self, Ps=None, Pe=None, O=None, r=1,
s_ang=None, e_ang=None, direction=1, drag=False, **kwargs):
"""
Standard Method to initialize the ArcGeo. Not all of the parameters are
required to fully define a arc. eg. Ps and Pe may be given or s_ang and
e_ang
@param Ps: The Start Point of the arc
@param Pe: the End Point of the arc
@param O: The center of the arc
@param r: The radius of the arc
@param s_ang: The Start Angle of the arc
@param e_ang: the End Angle of the arc
@param direction: The arc direction where 1 is in positive direction
"""
if ("geo" in kwargs) and ("parent" in kwargs):
geo = kwargs["geo"]
parent = kwargs["parent"]
Ps = geo.Ps.rot_sca_abs(parent=parent)
Pe = geo.Pe.rot_sca_abs(parent=parent)
O = geo.O.rot_sca_abs(parent=parent)
r = geo.scaled_r(geo.r, parent)
direction = 1 if geo.ext > 0.0 else -1
if parent is not None and parent.sca[0] * parent.sca[1] < 0.0:
direction *= -1
ArcGeo.__init__(self, Ps=Ps, Pe=Pe, O=O, r=r,
s_ang=s_ang, e_ang=e_ang,
direction=direction, drag=drag)
def distance(self, other):
"""
Find the distance between 2 geometry elements. Possible is LineGeo
and ArcGeo
@param other: the instance of the 2nd geometry element.
@return: The distance between the two geometries
"""
"""
Find the distance between 2 geometry elements. Possible is Point,
LineGeo and ArcGeo
@param other: the instance of the 2nd geometry element.
@return: The distance between the two geometries
"""
if isinstance(other, LineGeo):
return other.distance_l_a(self)
elif isinstance(other, Point):
return self.distance_a_p(other)
elif isinstance(other, ArcGeo):
return self.distance_a_a(other)
else:
logger.error(
self.tr("Unsupported geometry type: %s" % type(other)))
def distance_a_a(self, other):
"""
Find the distance between two arcs
@param other: the instance of the 2nd geometry element.
@return: The distance between the two geometries
"""
# logger.error('Unsupported function')
Pself = self.get_nearest_point(other)
Pother = other.get_nearest_point(self)
return Pself.distance(Pother)
def find_inter_point(self, other=[], typ='TIP'):
"""
Find the intersection between 2 geometry elements.
Possible is CCLineGeo and ArcGeo
@param other: the instance of the 2nd geometry element.
@param typ: Can be "TIP" for True Intersection Point or "Ray" for
Intersection which is in Ray (of Line)
@return: a list of intersection points.
"""
if isinstance(other, LineGeo):
IPoints = other.find_inter_point_l_a(self, typ)
return IPoints
elif isinstance(other, ArcGeo):
return self.find_inter_point_a_a(other, typ)
else:
logger.error("Unsupported Instance: %s" % other.type)
def find_inter_point_a_a(self, other, typ='TIP'):
"""
Find the intersection between 2 ArcGeo elements. There can be only one
intersection between 2 lines.
@param other: the instance of the 2nd geometry element.
@param typ: Can be "TIP" for True Intersection Point or "Ray" for
Intersection which is in Ray (of Line)
@return: a list of intersection points.
"""
if typ == "TIP" and self.Ps.distance(other.Pe) < eps * 5:
return other.Pe
elif typ == "TIP" and self.Pe.distance(other.Ps) < eps * 5:
return other.Ps
O_dis = self.O.distance(other.O)
# If self circle is surrounded by the other no intersection
if(O_dis < abs(self.r - other.r)):
return None
# If other circle is surrounded by the self no intersection
if(O_dis < abs(other.r - self.r)):
return None
# If The circles are to far away from each other no intersection
# possible
if (O_dis > abs(other.r + self.r)):
return None
# If both circles have the same center and radius
if abs(O_dis) == 0.0 and abs(self.r - other.r) == 0.0:
Pi1 = Point(x=self.Ps.x, y=self.Ps.y)
Pi2 = Point(x=self.Pe.x, y=self.Pe.y)
return [Pi1, Pi2]
# The following algorithm was found on :
# http://www.sonoma.edu/users/w/wilsonst/Papers/Geometry/circles/default.htm
root = ((pow(self.r + other.r, 2) - pow(O_dis, 2)) *
(pow(O_dis, 2) - pow(other.r - self.r, 2)))
# If the Line is a tangent the root is 0.0.
if root <= 0.0:
root = 0.0
else:
root = sqrt(root)
xbase = (other.O.x + self.O.x) / 2 + \
(other.O.x - self.O.x) * \
(pow(self.r, 2) - pow(other.r, 2)) / (2 * pow(O_dis, 2))
ybase = (other.O.y + self.O.y) / 2 + \
(other.O.y - self.O.y) * \
(pow(self.r, 2) - pow(other.r, 2)) / (2 * pow(O_dis, 2))
Pi1 = Point(x=xbase + (other.O.y - self.O.y) /
(2 * pow(O_dis, 2)) * root,
y=ybase - (other.O.x - self.O.x) /
(2 * pow(O_dis, 2)) * root)
Pi1_v1 = self.dif_ang(self.Ps, Pi1, self.ext) / self.ext
Pi1_v2 = other.dif_ang(other.Ps, Pi1, other.ext) / other.ext
Pi2 = Point(x=xbase - (other.O.y - self.O.y) /
(2 * pow(O_dis, 2)) * root,
y=ybase + (other.O.x - self.O.x) /
(2 * pow(O_dis, 2)) * root)
Pi2_v1 = self.dif_ang(self.Ps, Pi2, self.ext) / self.ext
Pi2_v2 = other.dif_ang(other.Ps, Pi2, other.ext) / other.ext
if typ == 'TIP':
if ((Pi1_v1 >= 0.0 and Pi1_v1 <= 1.0 and
Pi1_v2 > 0.0 and Pi1_v2 <= 1.0) and
(Pi2_v1 >= 0.0 and Pi2_v1 <= 1.0 and
Pi2_v2 > 0.0 and Pi2_v2 <= 1.0)):
if (root == 0):
return Pi1
else:
return [Pi1, Pi2]
elif (Pi1_v1 >= 0.0 and Pi1_v1 <= 1.0 and
Pi1_v2 > 0.0 and Pi1_v2 <= 1.0):
return Pi1
elif (Pi2_v1 >= 0.0 and Pi2_v1 <= 1.0 and
Pi2_v2 > 0.0 and Pi2_v2 <= 1.0):
return Pi2
else:
return None
elif typ == "Ray":
# If the root is zero only one solution and the line is a tangent.
if root == 0:
return Pi1
else:
return [Pi1, Pi2]
else:
logger.error("We should not be here")
def get_nearest_point(self, other):
"""
Get the nearest point on the arc to another geometry.
@param other: The Line to be nearest to
@return: The point which is the nearest to other
"""
if isinstance(other, LineGeo):
return other.get_nearest_point_l_a(self, ret="arc")
elif isinstance(other, ArcGeo):
return self.get_nearest_point_a_a(other)
elif isinstance(other, Point):
return self.get_nearest_point_a_p(other)
else:
logger.error("Unsupported Instance: %s" % other.type)
def get_nearest_point_a_p(self, other):
"""
Get the nearest point to a point lieing on the arc
@param other: The Point to be nearest to
@return: The point which is the nearest to other
"""
if self.intersect(other):
return other
PPoint = self.O.get_arc_point(self.O.norm_angle(other), r=self.r)
if self.intersect(PPoint):
return PPoint
elif self.Ps.distance(other) < self.Pe.distance(other):
return self.Ps
else:
return self.Pe
def get_nearest_point_a_a(self, other):
"""
Get the nearest point to a line lieing on the line
@param other: The Point to be nearest to
@return: The point which is the nearest to other
"""
if self.intersect(other):
return self.find_inter_point_a_a(other)
# If Nearest point is on both Arc Segments.
if (other.PointAng_withinArc(self.O) and
self.PointAng_withinArc(other.O)):
return self.O.get_arc_point(self.O.norm_angle(other.O),
r=self.r)
# If Nearest point is at one of the start/end points
else:
dismin = self.Ps.distance(other)
retpoint = self.Ps
newdis = self.Pe.distance(other)
if newdis < dismin:
dismin = newdis
retpoint = self.Pe
newdis = other.Ps.distance(self)
if newdis < dismin:
dismin = newdis
retpoint = self.get_nearest_point_a_p(other.Ps)
newdis = other.Pe.distance(self)
if newdis < dismin:
dismin = newdis
retpoint = self.get_nearest_point_a_p(other.Pe)
return retpoint
def intersect(self, other):
"""
Check if there is an intersection of two geometry elements
@param, a second geometry which shall be checked for intersection
@return: True if there is an intersection
"""
# Do a raw check first with BoundingBox
# logger.debug("self: %s, \nother: %s, \nintersect: %s"
# %(self,other,self.BB.hasintersection(other.BB)))
# logger.debug("self.BB: %s \nother.BB: %s")
# We need to test Point first cause it has no BB
if isinstance(other, Point):
return self.intersect_a_p(other)
elif not(self.BB.hasintersection(other.BB)):
return False
elif isinstance(other, LineGeo):
return other.intersect_l_a(self)
elif isinstance(other, ArcGeo):
return self.intersect_a_a(other)
else:
logger.error("Unsupported Instance: %s" % other.type)
def intersect_a_a(self, other):
"""
Check if there is an intersection of two arcs
@param, a second arc which shall be checked for intersection
@return: True if there is an intersection
"""
inter = self.find_inter_point_a_a(other)
return not(inter is None)
def intersect_a_p(self, other):
"""
Check if there is an intersection of an point and a arc
@param, a second arc which shall be checked for intersection
@return: True if there is an intersection
"""
# No intersection possible if point is not within radius
if not(abs(self.O.distance(other) - self.r) < eps):
return False
elif self.PointAng_withinArc(other):
return True
else:
return False
def match_Ps_to_Pe(self, otherPe):
"""
This functions adapts the geometry in the way so that the
startpoint exactly matches the given point
@param otherPe: This is the end point of the other geometry to
match with
"""
self.Ps = otherPe
# Get the Circle center point with known Start and End Points
self.O.x = self.Ps.x - self.r * cos(self.s_ang)
self.O.y = self.Ps.y - self.r * sin(self.s_ang)
self.length = self.r * abs(self.ext)
self.calc_bounding_box()
self.abs_geo = None
def PointAng_withinArc(self, Point):
"""
Check if the angle defined by Point is within the span of the arc.
@param Point: The Point which angle to be checked
@return: True or False
"""
if self.ext == 0.0:
return False
v = self.dif_ang(self.Ps, Point, self.ext) / self.ext
return v >= 0.0 and v <= 1.0
def split_into_2geos(self, ipoint=Point()):
"""
Splits the given geometry into 2 geometries. The
geometry will be splitted at ipoint.
@param ipoint: The Point where the intersection occures
@return: A list of 2 ArcGeo's will be returned.
"""
# Generate the 2 geometries and their bounding boxes.
Arc1 = OffArcGeo(Ps=self.Ps, Pe=ipoint, r=self.r,
O=self.O, direction=self.ext)
Arc2 = OffArcGeo(Ps=ipoint, Pe=self.Pe, r=self.r,
O=self.O, direction=self.ext)
return [Arc1, Arc2]
def trim(self, Point, dir=1, rev_norm=False):
"""
This instance is used to trim the geometry at the given point. The
point can be a point on the offset geometry a perpendicular point on
line will be used for trimming.
@param Point: The point / perpendicular point for new Geometry
@param dir: The direction in which the geometry will be kept (1 means
the beginn will be trimmed)
@param rev_norm: If the direction of the point is on the reversed side.
"""
# logger.debug("I'm getting trimmed: %s, %s, %s, %s"
# % (self, Point, dir, rev_norm))
newPoint = self.O.get_arc_point(self.O.norm_angle(Point), r=self.r)
new_normal = self.O.unit_vector(newPoint, r=1)
if self.ext < 0:
new_normal = new_normal * -1
# new_normal = newPoint.unit_vector(self.O, r=1)
#
# if self.ext<0:
# new_normal = new_normal*-1
# logger.debug(newPoint)
[Arc1, Arc2] = self.split_into_2geos(newPoint)
if dir == -1:
new_arc = Arc1
if hasattr(self, "end_normal"):
# new_arc.end_normal = self.end_normal
# new_arc.start_normal = new_normal
new_arc.end_normal = new_normal
new_arc.start_normal = self.start_normal
# logger.debug(new_arc)
return new_arc
else:
new_arc = Arc2
if hasattr(self, "end_normal"):
# new_arc.end_normal = new_normal
# new_arc.start_normal = self.start_normal
new_arc.end_normal = self.end_normal
new_arc.start_normal = new_normal
# logger.debug(new_arc)
return new_arc
class OffLineGeo(LineGeo):
"""
Inherited Class for Shapeoffset only. All related offset functions are
concentrated here in orde to keep base classes as clean as possible.
"""
def __init__(self, Ps=None, Pe=None, **kwargs):
"""
Standard Method to initialize the LineGeo.
@param Ps: The Start Point of the line
@param Pe: the End Point of the line
"""
if ("geo" in kwargs) and ("parent" in kwargs):
geo = kwargs["geo"]
parent = kwargs["parent"]
Ps = geo.Ps.rot_sca_abs(parent=parent)
Pe = geo.Pe.rot_sca_abs(parent=parent)
LineGeo.__init__(self, Ps=Ps, Pe=Pe)
def colinear(self, other):
"""
Check if two lines with same point self.Pe==other.Ps are colinear. For
Point it check if the point is colinear with the line self.
@param other: the possibly colinear line
"""
if isinstance(other, LineGeo):
return ((self.Ps.ccw(self.Pe, other.Pe) == 0) and
(self.Ps.ccw(self.Pe, other.Ps) == 0))
elif isinstance(other, Point):
"""
Return true iff a, b, and c all lie on the same line."
"""
return self.Ps.ccw(self.Pe, other) == 0
else:
logger.debug("Unsupported instance: %s" % type(other))
def colinearoverlapping(self, other):
"""
Check if the lines are colinear overlapping
Ensure AC, then the intersection is the segment [C, min(B, D)]
@param other: The other line
@return: True if they are overlapping
"""
if not(self.colinear(other)):
return False
else:
if self.Ps < self.Pe:
A = self.Ps
B = self.Pe
else:
A = self.Pe
B = self.Ps
if other.Ps < self.Pe:
C = other.Ps
D = other.Pe
else:
C = other.Pe
D = other.Ps
# Swap lines if required
if not(A <= C):
A, B, C, D = C, D, A, B
if B < C:
return False
elif B == C:
return False
else:
return True
def colinearconnected(self, other):
"""
Check if Lines are connected and colinear
@param other: Another Line which will be checked
"""
if not(self.colinear(other)):
return False
elif self.Ps == other.Ps:
return True
elif self.Pe == other.Ps:
return True
elif self.Ps == other.Pe:
return True
elif self.Pe == other.Pe:
return True
else:
return False
def distance(self, other=[]):
"""
Find the distance between 2 geometry elements. Possible is CCLineGeo
and ArcGeo
@param other: the instance of the 2nd geometry element.
@return: The distance between the two geometries
"""
if isinstance(other, LineGeo):
return self.distance_l_l(other)
elif isinstance(other, Point):
return self.distance_l_p(other)
elif isinstance(other, ArcGeo):
return self.distance_l_a(other)
else:
logger.error(
self.tr("Unsupported geometry type: %s" % type(other)))
def distance_l_l(self, other):
"""
Find the distance between 2 ccLineGeo elements.
@param other: the instance of the 2nd geometry element.
@return: The distance between the two geometries
"""
if self.intersect(other):
return 0.0
return min(self.distance_l_p(other.Ps),
self.distance_l_p(other.Pe),
other.distance_l_p(self.Ps),
other.distance_l_p(self.Pe))
def distance_l_a(self, other):
"""
Find the distance between 2 ccLineGeo elements.
@param other: the instance of the 2nd geometry element.
@return: The distance between the two geometries
"""
if self.intersect(other):
return 0.0
# Get the nearest Point to the Center of the Arc
POnearest = self.get_nearest_point_l_p(other.O)
# The Line is outside of the Arc
if other.O.distance(POnearest) > other.r:
# If the Nearest Point is on Arc Segement it is the neares one.
# logger.debug("Nearest Point is outside of arc")
if other.PointAng_withinArc(POnearest):
return POnearest.distance(other.O.get_arc_point(other.O.norm_angle(POnearest),
r=other.r))
elif self.distance(other.Ps) < self.distance(other.Pe):
return self.get_nearest_point(other.Ps).distance(other.Ps)
else:
return self.get_nearest_point(other.Pe).distance(other.Pe)
# logger.debug("Nearest Point is Inside of arc")
# logger.debug("self.distance(other.Ps): %s, self.distance(other.Pe):
# %s" %(self.distance(other.Ps),self.distance(other.Pe)))
# The Line may be inside of the ARc or cross it
if self.distance(other.Ps) < self.distance(other.Pe):
dis_min = self.distance(other.Ps)
# logger.debug("Pnearest: %s, distance: %s" %(Pnearest, dis_min))
else:
dis_min = self.distance(other.Pe)
# logger.debug("Pnearest: %s, distance: %s" %(Pnearest, dis_min))
if ((other.PointAng_withinArc(self.Ps)) and
abs(other.r - other.O.distance(self.Ps)) < dis_min):
dis_min = abs(other.r - other.O.distance(self.Ps))
# logger.debug("Pnearest: %s, distance: %s" %(Pnearest, dis_min))
if ((other.PointAng_withinArc(self.Pe)) and
abs((other.r - other.O.distance(self.Pe))) < dis_min):
dis_min = abs(other.r - other.O.distance(self.Pe))
# logger.debug("Pnearest: %s, distance: %s" %(Pnearest, dis_min))
return dis_min
def find_inter_point(self, other, typ='TIP'):
"""
Find the intersection between 2 Geo elements. There can be only one
intersection between 2 lines. Returns also FIP which lay on the ray.
@param other: the instance of the 2nd geometry element.
@param typ: Can be "TIP" for True Intersection Point or "Ray" for
Intersection which is in Ray (of Line)
@return: a list of intersection points.
"""
if isinstance(other, LineGeo):
inter = self.find_inter_point_l_l(other, typ)
return inter
elif isinstance(other, ArcGeo):
inter = self.find_inter_point_l_a(other, typ)
return inter
else:
logger.error("Unsupported Instance: %s" % other.type)
def find_inter_point_l_l(self, other, typ="TIP"):
"""
Find the intersection between 2 LineGeo elements. There can be only one
intersection between 2 lines. Returns also FIP which lay on the ray.
@param other: the instance of the 2nd geometry element.
@param typ: Can be "TIP" for True Intersection Point or "Ray" for
Intersection which is in Ray (of Line)
@return: a list of intersection points.
"""
if self.colinear(other):
return None
elif typ == 'TIP' and not(self.intersect(other)):
return None
elif typ == "TIP" and self.Ps.distance(other.Pe) < eps * 5:
return other.Pe
elif typ == "TIP" and self.Pe.distance(other.Ps) < eps * 5:
return other.Ps
dx1 = self.Pe.x - self.Ps.x
dy1 = self.Pe.y - self.Ps.y
dx2 = other.Pe.x - other.Ps.x
dy2 = other.Pe.y - other.Ps.y
dax = self.Ps.x - other.Ps.x
day = self.Ps.y - other.Ps.y
# Return nothing if one of the lines has zero length
if (dx1 == 0 and dy1 == 0) or (dx2 == 0 and dy2 == 0):
return None
# If to avoid division by zero.
try:
if(abs(dx2) >= abs(dy2)):
v1 = (day - dax * dy2 / dx2) / (dx1 * dy2 / dx2 - dy1)
# v2 = (dax + v1 * dx1) / dx2
else:
v1 = (dax - day * dx2 / dy2) / (dy1 * dx2 / dy2 - dx1)
# v2 = (day + v1 * dy1) / dy2
except:
return None
return Point(x=self.Ps.x + v1 * dx1,
y=self.Ps.y + v1 * dy1)
def find_inter_point_l_a(self, Arc, typ="TIP"):
"""
Find the intersection between 2 Geo elements. The intersection between
a Line and a Arc is checked here. This function is also used in the
Arc Class to check Arc -> Line Intersection (the other way around)
@param Arc: the instance of the 2nd geometry element.
@param typ: Can be "TIP" for True Intersection Point or "Ray" for
Intersection which is in Ray (of Line)
@return: a list of intersection points.
"""
if typ == "TIP" and self.Ps.distance(Arc.Pe) < eps * 5:
return Arc.Pe
elif typ == "TIP" and self.Pe.distance(Arc.Ps) < eps * 5:
return Arc.Ps
Ldx = self.Pe.x - self.Ps.x
Ldy = self.Pe.y - self.Ps.y
# Mitternachtsformel zum berechnen der Nullpunkte der quadratischen
# Gleichung
a = pow(Ldx, 2) + pow(Ldy, 2)
b = 2 * Ldx * (self.Ps.x - Arc.O.x) + 2 * Ldy * (self.Ps.y - Arc.O.y)
c = pow(self.Ps.x - Arc.O.x, 2) + \
pow(self.Ps.y - Arc.O.y, 2) - pow(Arc.r, 2)
root = pow(b, 2) - 4 * a * c
# If the value under the sqrt is negative there is no intersection.
if root < 0 or a == 0.0:
return None
v1 = (-b + sqrt(root)) / (2 * a)
v2 = (-b - sqrt(root)) / (2 * a)
Pi1 = Point(x=self.Ps.x + v1 * Ldx,
y=self.Ps.y + v1 * Ldy)
Pi2 = Point(x=self.Ps.x + v2 * Ldx,
y=self.Ps.y + v2 * Ldy)
Pi1_v = Arc.dif_ang(Arc.Ps, Pi1, Arc.ext) / Arc.ext
Pi2_v = Arc.dif_ang(Arc.Ps, Pi2, Arc.ext) / Arc.ext
if typ == 'TIP':
if ((Pi1_v >= 0.0 and Pi1_v <= 1.0 and self.intersect(Pi1)) and
(Pi1_v >= 0.0 and Pi2_v <= 1.0 and self.intersect(Pi2))):
if (root == 0):
return Pi1
else:
return [Pi1, Pi2]
elif (Pi1_v >= 0.0 and Pi1_v <= 1.0 and self.intersect(Pi1)):
return Pi1
elif (Pi1_v >= 0.0 and Pi2_v <= 1.0 and self.intersect(Pi2)):
return Pi2
else:
return None
elif typ == "Ray":
# If the root is zero only one solution and the line is a tangent.
if(root == 0):
return Pi1
return [Pi1, Pi2]
else:
logger.error("We should not be here")
def get_nearest_point(self, other):
"""
Get the nearest point on a line to another line lieing on the line
@param other: The Line to be nearest to
@return: The point which is the nearest to other
"""
if isinstance(other, LineGeo):
return self.get_nearest_point_l_l(other)
elif isinstance(other, ArcGeo):
return self.get_nearest_point_l_a(other)
elif isinstance(other, Point):
return self.get_nearest_point_l_p(other)
else:
logger.error("Unsupported Instance: %s" % other.type)
def get_nearest_point_l_l(self, other):
"""
Get the nearest point on a line to another line lieing on the line
@param other: The Line to be nearest to
@return: The point which is the nearest to other
"""
# logger.debug(self.intersect(other))
if self.intersect(other):
return self.find_inter_point_l_l(other)
min_dis = self.distance(other)
if min_dis == self.distance_l_p(other.Ps):
return self.get_nearest_point_l_p(other.Ps)
elif min_dis == self.distance_l_p(other.Pe):
return self.get_nearest_point_l_p(other.Pe)
elif min_dis == other.distance_l_p(self.Ps):
return self.Ps
elif min_dis == other.distance_l_p(self.Pe):
return self.Pe
else:
logger.warning("No solution found")
def get_nearest_point_l_a(self, other, ret="line"):
"""
Get the nearest point to a line lieing on the line
@param other: The Point to be nearest to
@return: The point which is the nearest to other
"""
if self.intersect(other):
return self.find_inter_point_l_a(other)
# Get the nearest Point to the Center of the Arc
POnearest = self.get_nearest_point_l_p(other.O)
# The Line is outside of the Arc
if other.O.distance(POnearest) > other.r:
# If the Nearest Point is on Arc Segement it is the neares one.
# logger.debug("Nearest Point is outside of arc")
if other.PointAng_withinArc(POnearest):
if ret == "line":
return POnearest
elif ret == "arc":
return other.O.get_arc_point(other.O.norm_angle(POnearest),
r=other.r)
elif self.distance(other.Ps) < self.distance(other.Pe):
if ret == "line":
return self.get_nearest_point(other.Ps)
elif ret == "arc":
return other.Ps
else:
if ret == "line":
return self.get_nearest_point(other.Pe)
elif ret == "art":
return other.Pe
# logger.debug("Nearest Point is Inside of arc")
# logger.debug("self.distance(other.Ps): %s, self.distance(other.Pe):
# %s" %(self.distance(other.Ps),self.distance(other.Pe)))
# The Line may be inside of the ARc or cross it
if self.distance(other.Ps) < self.distance(other.Pe):
Pnearest = self.get_nearest_point(other.Ps)
Pnother = other.Ps
dis_min = self.distance(other.Ps)
# logger.debug("Pnearest: %s, distance: %s" %(Pnearest, dis_min))
else:
Pnearest = self.get_nearest_point(other.Pe)
Pnother = other.Pe
dis_min = self.distance(other.Pe)
# logger.debug("Pnearest: %s, distance: %s" %(Pnearest, dis_min))
if ((other.PointAng_withinArc(self.Ps)) and
abs(other.r - other.O.distance(self.Ps)) < dis_min):
Pnearest = self.Ps
Pnother = other.O.get_arc_point(
other.O.norm_angle(Pnearest), r=other.r)
dis_min = abs(other.r - other.O.distance(self.Ps))
# logger.debug("Pnearest: %s, distance: %s" %(Pnearest, dis_min))
if ((other.PointAng_withinArc(self.Pe)) and
abs((other.r - other.O.distance(self.Pe))) < dis_min):
Pnearest = self.Pe
Pnother = other.O.get_arc_point(
other.O.norm_angle(Pnearest), r=other.r)
dis_min = abs(other.r - other.O.distance(self.Pe))
# logger.debug("Pnearest: %s, distance: %s" %(Pnearest, dis_min))
if ret == "line":
return Pnearest
elif ret == "arc":
return Pnother
def get_nearest_point_l_p(self, other):
"""
Get the nearest point to a point lieing on the line
@param other: The Point to be nearest to
@return: The point which is the nearest to other
"""
if self.intersect(other):
return other
PPoint = self.perpedicular_on_line(other)
if self.intersect(PPoint):
return PPoint
if self.Ps.distance(other) < self.Pe.distance(other):
return self.Ps
else:
return self.Pe
def intersect(self, other):
"""
Check if there is an intersection of two geometry elements
@param, a second geometry which shall be checked for intersection
@return: True if there is an intersection
"""
# Do a raw check first with BoundingBox
# logger.debug("self: %s, \nother: %s, \nintersect: %s"
# %(self,other,self.BB.hasintersection(other.BB)))
# logger.debug("self.BB: %s \nother.BB: %s")
# logger.debug(self.BB.hasintersection(other.BB))
# We need to test Point first cause it has no BB
if isinstance(other, Point):
return self.intersect_l_p(other)
elif not(self.BB.hasintersection(other.BB)):
return False
elif isinstance(other, LineGeo):
return self.intersect_l_l(other)
elif isinstance(other, ArcGeo):
return self.intersect_l_a(other)
else:
logger.error("Unsupported Instance: %s" % other.type)
def intersect_l_a(self, other):
"""
Check if there is an intersection of the two line
@param, a second line which shall be checked for intersection
@return: True if there is an intersection
"""
inter = self.find_inter_point_l_a(other)
return not(inter is None)
def intersect_l_l(self, other):
"""
Check if there is an intersection of the two line
@param, a second line which shall be checked for intersection
@return: True if there is an intersection
"""
A = self.Ps
B = self.Pe
C = other.Ps
D = other.Pe
return A.ccw(C, D) != B.ccw(C, D) and A.ccw(B, C) != A.ccw(B, D)
def intersect_l_p(self, Point):
"""
Check if Point is colinear and within the Line
@param Point: A Point which will be checked
@return: True if point Point intersects the line segment from Ps to Pe.
Refer to http://stackoverflow.com/questions/328107/
how-can-you-determine-a-point-is-between-two-other-points-on-a-line-segment
"""
# (or the degenerate case that all 3 points are coincident)
# logger.debug(self.colinear(Point))
return (self.colinear(Point)
and (self.within(self.Ps.x, Point.x, self.Pe.x)
if self.Ps.x != self.Pe.x else
self.within(self.Ps.y, Point.y, self.Pe.y)))
def join_colinear_line(self, other):
"""
Check if the two lines are colinear connected or inside of each other,
in this case these lines will be joined to one common line, otherwise
return both lines
@param other: a second line
@return: Return one or two lines
"""
if self.colinearconnected(other)or self.colinearoverlapping(other):
if self.Ps < self.Pe:
newPs = min(self.Ps, other.Ps, other.Pe)
newPe = max(self.Pe, other.Ps, other.Pe)
else:
newPs = max(self.Ps, other.Ps, other.Pe)
newPe = min(self.Pe, other.Ps, other.Pe)
return [OffLineGeo(newPs, newPe)]
else:
return [self, other]
def match_Ps_to_Pe(self, otherPe):
"""
This functions adapts the geometry in the way so that the
startpoint exactly matches the given point
@param otherPe: This is the end point of the other geometry to
match with
"""
self.Ps = otherPe
self.length = self.Ps.distance(self.Pe)
self.calc_bounding_box()
self.abs_geo = None
def perpedicular_on_line(self, other):
"""
This function calculates the perpendicular point on a line (or ray of
line) with the shortest distance to the point given with other
@param other: The point to be perpendicular to
@return: A point which is on line and perpendicular to Point other
@see: http://stackoverflow.com/questions/1811549/
perpendicular-on-a-line-from-a-given-point
"""
# first convert line to normalized unit vector
unit_vector = self.Ps.unit_vector(self.Pe)
# translate the point and get the dot product
lam = ((unit_vector.x * (other.x - self.Ps.x))
+ (unit_vector.y * (other.y - self.Ps.y)))
return Point(x=(unit_vector.x * lam) + self.Ps.x,
y = (unit_vector.y * lam) + self.Ps.y)
def split_into_2geos(self, ipoint=Point()):
"""
Splits the given geometry into 2 not self intersection geometries. The
geometry will be splitted between ipoint and Pe.
@param ipoint: The Point where the intersection occures
@return: A list of 2 CCLineGeo's will be returned if Point is inside
"""
# The Point where the geo shall be splitted
if not(ipoint):
return [self]
elif self.intersect(ipoint):
Li1 = OffLineGeo(Ps=self.Ps, Pe=ipoint)
Li2 = OffLineGeo(Ps=ipoint, Pe=self.Pe)
return [Li1, Li2]
else:
return [self]
def trim(self, Point, dir=1, rev_norm=False):
"""
This instance is used to trim the geometry at the given point. The
point can be a point on the offset geometry a perpendicular point on
line will be used for trimming.
@param Point: The point / perpendicular point for new Geometry
@param dir: The direction in which the geometry will be kept (1 means
the being will be trimmed)
"""
newPoint = self.perpedicular_on_line(Point)
if dir == 1:
new_line = OffLineGeo(newPoint, self.Pe)
new_line.end_normal = self.end_normal
new_line.start_normal = self.start_normal
return new_line
else:
new_line = OffLineGeo(self.Ps, newPoint)
new_line.end_normal = self.end_normal
new_line.start_normal = self.start_normal
return new_line
def within(self, p, q, r):
"Return true iff q is between p and r (inclusive)."
return p <= q <= r or r <= q <= p
class OffPoint(Point):
"""
Inherited Class for Shapeoffset only. All related offset functions are
concentrated here in orde to keep base classes as clean as possible.
"""
def __init__(self, x=0, y=0, **kwargs):
if ("geo" in kwargs) and ("parent" in kwargs):
logger.debug("Alles da")
geo = kwargs["geo"]
parent = kwargs["parent"]
x = geo.rot_sca_abs(parent=parent).x
y = geo.rot_sca_abs(parent=parent).y
self.x = x
self.y = y
class ConvexPoint(OffPoint):
"""
Inherited Class of OffPoint required to identify Convex Points in the
Offset algorithm..
"""
def __init__(self, x=0, y=0):
OffPoint.__init__(self, x=x, y=y)
def __str__(self):
return 'X ->%6.3f Y ->%6.3f' % (self.x, self.y)
# return ('CPoints.append(Point(x=%6.5f, y=%6.5f))' %(self.x,self.y))