jwwkit 0.2.0__py3-none-any.whl

jwwkit/_tategu_features.py

@@ -0,0 +1,201 @@
+"""Geometric hypotheses: radial swing, folded double edges and framed parallel rails.
+
+No DAT templates, nominal dimension list, labels, curve-group IDs or reference
+regions are used. Constants below are dimensionless feature guards, not a
+substitute for the explicitly supplied metric tolerances.
+"""
+import math
+from jwwkit._tategu_geometry import dot,sub,cross,distance,arc_point,point_segment,box
+
+
+def axis(line):
+    v=sub(line['b'],line['a']);length=math.hypot(*v);u=(v[0]/length,v[1]/length)
+    if u[1]<0 or abs(u[1])<1e-12 and u[0]<0:u=(-u[0],-u[1])
+    return u
+
+
+def parallel_vectors(a,b,eps):
+    length=max(math.hypot(*a),math.hypot(*b))
+    return length>0 and math.atan2(abs(cross(a,b)),abs(dot(a,b)))<=math.atan(eps/length)
+
+
+def project(lines,u,eps,reference_length=1.):
+    v=(-u[1],u[0]);parallel=[];normal=[];diagonal=[]
+    for r in lines:
+        a,b=r['a'],r['b'];d=sub(b,a)
+        p0,p1=dot(a,u),dot(b,u);q0,q1=dot(a,v),dot(b,v)
+        item=dict(record=r,lo=min(p0,p1),hi=max(p0,p1),q=(q0+q1)/2,
+                  qlo=min(q0,q1),qhi=max(q0,q1),p=(p0+p1)/2)
+        reference=(u[0]*reference_length,u[1]*reference_length)
+        if parallel_vectors(d,reference,eps):parallel.append(item)
+        elif parallel_vectors(d,(-reference[1],reference[0]),eps):normal.append(item)
+        else:diagonal.append(item)
+    return parallel,normal,diagonal
+
+
+def point(u,p,q):return (u[0]*p-u[1]*q,u[1]*p+u[0]*q)
+
+
+def support(rows,u,lo,hi,qlo,qhi,margin,always=()):
+    ids=set(always)
+    for r in rows:
+        if r['kind']!='LINE':continue
+        values=[(dot(p,u),dot(p,(-u[1],u[0])))for p in (r['a'],r['b'])]
+        if all(lo-margin<=p<=hi+margin and qlo-margin<=q<=qhi+margin for p,q in values):ids.add(r['index'])
+    return sorted(ids)
+
+
+def hypothesis(kind,width,endpoints,ids,evidence,*,direction=None,ambiguities=(),method):
+    return dict(type_candidates=[kind],clear_width_mm=width,
+        position_real_mm=[(endpoints[0][i]+endpoints[1][i])/2 for i in (0,1)],
+        opening_endpoints_real_mm=[list(p)for p in endpoints],element_indices=sorted(ids),
+        opening_direction=direction,evidence=evidence,ambiguities=list(ambiguities),measurement_method=method)
+
+
+def swing(rows,eps,width_eps):
+    arcs=[r for r in rows if r['kind']=='ARC'];lines=[r for r in rows if r['kind']=='LINE'];out=[]
+    for arc in arcs:
+        verified=[];fallback=[]
+        h=arc['center'];radius=arc['radius']
+        ends=[arc_point(arc,arc['start']),arc_point(arc,arc['start']+arc['sweep'])]
+        for n,leafend in enumerate(ends):
+            leaves=[r for r in lines if min(distance(r['a'],h)+distance(r['b'],leafend),distance(r['b'],h)+distance(r['a'],leafend))<=2*eps]
+            if not leaves:continue
+            closed=ends[1-n];u=((closed[0]-h[0])/radius,(closed[1]-h[1])/radius)
+            parallel,caps,_=project(lines,u,eps,radius);origin=dot(h,u);qhinge=dot(h,(-u[1],u[0]))
+            left=[c for c in caps if abs(c['p']-origin)<=width_eps and c['record']['length']<radius/2]
+            right=[c for c in caps if abs(c['p']-(origin+radius))<=width_eps and c['record']['length']<radius/2]
+            for a in left:
+                for b in right:
+                    if abs(a['qlo']-b['qlo'])>eps or abs(a['qhi']-b['qhi'])>eps:continue
+                    if not a['qlo']-eps<=qhinge<=a['qhi']+eps:continue
+                    measured=b['p']-a['p'];depth=a['qhi']-a['qlo']
+                    if measured<=eps or depth<=eps or abs(measured-radius)>width_eps:continue
+                    qcenter=(a['qlo']+a['qhi'])/2
+                    endpoints=[point(u,a['p'],qcenter),point(u,b['p'],qcenter)]
+                    leaf=leaves[0];leaf_u=((leafend[0]-h[0])/radius,(leafend[1]-h[1])/radius)
+                    direction=dict(hinge_real_mm=list(h),closed_ray_degrees=math.degrees(math.atan2(u[1],u[0]))%360,
+                        leaf_ray_degrees=math.degrees(math.atan2(leaf_u[1],leaf_u[0]))%360,
+                        signed_rotation_degrees=math.degrees(math.atan2(cross(u,leaf_u),dot(u,leaf_u))),
+                        handedness=None,inside_outside=None,reason='建物の内外基準がないため右勝手/内開き等へ読み替えない')
+                    leafq=dot(leafend,(-u[1],u[0]));qmin=min(a['qlo'],leafq);qmax=max(a['qhi'],leafq)
+                    ids=support(rows,u,a['p'],b['p'],qmin,qmax,depth+eps,
+                        always=[arc['index'],leaf['index'],a['record']['index'],b['record']['index']])
+                    verified.append(hypothesis('開戸',measured,endpoints,ids,
+                        ['円弧の中心から端点へ伸びる扉線を確認','閉鎖側の両端に同じ見込の枠内面線を確認',
+                         '幅は枠内面の投影間隔。半径/全体外形だけでは決めない'],
+                        direction=direction,method='paired_jamb_faces_with_radial_swing'))
+            if not verified:
+                fallback.append(hypothesis('開戸',None,[h,closed],[arc['index'],leaves[0]['index']],
+                    ['円弧中心と端点を結ぶ扉線は確認できる'],
+                    direction=dict(hinge_real_mm=list(h),handedness=None,inside_outside=None),
+                    ambiguities=['枠内面が両端で確定しないため半径を内法に読み替えない'],
+                    method='radial_swing_unverified_opening'))
+        # A closed-position line can also join an arc endpoint. An unverified
+        # reverse interpretation adds no evidence once the two jamb faces
+        # establish the opening for this same arc. Keep all verified variants.
+        out.extend(verified or fallback)
+    return out
+
+
+def folded(rows,eps):
+    lines=[r for r in rows if r['kind']=='LINE'];out=[]
+    for base in lines:
+        u=axis(base);length=base['length'];pa,pb=sorted((dot(base['a'],u),dot(base['b'],u)))
+        parallel,normal,diagonal=project(lines,u,eps,length)
+        long_diagonal=[d for d in diagonal if .1*length<=d['record']['length']<=.9*length]
+        if len(long_diagonal)<4:continue
+        endpoint_groups=[]
+        for endpoint in (base['a'],base['b']):
+            near=[d for d in long_diagonal if min(distance(endpoint,d['record']['a']),distance(endpoint,d['record']['b']))<=eps]
+            if not near:break
+            p=dot(endpoint,u)
+            local=[d for d in long_diagonal if min(abs(d['lo']-p),abs(d['hi']-p))<=length*.25]
+            doubled=False
+            for i,a in enumerate(local):
+                for b in local[:i]:
+                    av=sub(a['record']['b'],a['record']['a']);bv=sub(b['record']['b'],b['record']['a'])
+                    if parallel_vectors(av,bv,eps):
+                        separation=point_segment(a['record']['a'],b['record']['a'],b['record']['b'])
+                        if eps<separation<min(a['record']['length'],b['record']['length'])*.25:doubled=True
+            if not doubled:break
+            endpoint_groups.append(local)
+        if len(endpoint_groups)!=2:continue
+        if {d['record']['index']for d in endpoint_groups[0]}&{d['record']['index']for d in endpoint_groups[1]}:continue
+        q=dot(base['a'],(-u[1],u[0]));diagonal_ids={d['record']['index']for part in endpoint_groups for d in part}
+        local=[base]+[d['record']for part in endpoint_groups for d in part]
+        bb=box(local);ids=[r['index']for r in rows if r['bbox'][0]>=bb[0]-eps and r['bbox'][1]>=bb[1]-eps and r['bbox'][2]<=bb[2]+eps and r['bbox'][3]<=bb[3]+eps]
+        ids.extend(n['record']['index']for n in normal if n['record']['length']<=length*.25 and pa-eps<=n['p']<=pb+eps and n['qlo']-eps<=q<=n['qhi']+eps)
+        ids=sorted(set(ids))
+        # Baseline joins both folded double-edge assemblies; it is not a bounding-box dimension.
+        out.append(hypothesis('折れ戸',length,[point(u,pa,q),point(u,pb,q)],ids,
+            ['直線の開口基準線の両端に、斜めの二重線の組を確認','両端の折れた戸先形状と基準線の接続を確認',
+             '幅は両端取付位置を結ぶ基準線長。全体外形幅ではない'],
+            direction=dict(axis_degrees=math.degrees(math.atan2(u[1],u[0]))%180,
+                side_of_fold='positive'if sum(d['q']-q for d in long_diagonal)>0 else 'negative',
+                handedness=None,inside_outside=None),method='baseline_between_folded_leaf_assemblies'))
+    return out
+
+
+def framed(rows,eps):
+    lines=[r for r in rows if r['kind']=='LINE'];axes=[];out=[]
+    for r in sorted(lines,key=lambda x:-x['length']):
+        u=axis(r)
+        if not any(parallel_vectors(sub(r['b'],r['a']),(other[0]*length,other[1]*length),eps) for other,length in axes):axes.append((u,r['length']))
+    for u,reference_length in axes:
+        parallel,normal,_=project(lines,u,eps,reference_length);frames=[];intervals=[]
+        for line in parallel:
+            match=next((part for part in intervals if abs(part[0]['lo']-line['lo'])<=eps and abs(part[0]['hi']-line['hi'])<=eps),None)
+            if match is None:intervals.append([line])
+            else:match.append(line)
+        for part in intervals:
+            if len(part)<3:continue
+            lo,hi=part[0]['lo'],part[0]['hi'];qlow=min(p['q']for p in part);qhigh=max(p['q']for p in part)
+            if hi-lo<=eps or not eps<qhigh-qlow<(hi-lo)*.5:continue
+            caps=[[n for n in normal if abs(n['p']-p)<=eps and sum(n['qlo']-eps<=line['q']<=n['qhi']+eps for line in part)>=2]for p in (lo,hi)]
+            if all(caps):frames.append(dict(lo=lo,hi=hi,qlo=qlow,qhi=qhigh,source='continuous_rails_and_inner_jamb_faces',ids=[c[0]['record']['index']for c in caps]))
+        # Opposed H/box jamb profiles: the facing ends of the short parallel arms
+        # define the clear opening; the outside endpoints are not used as width.
+        brackets=[]
+        for part in intervals:
+            if len(part)<2:continue
+            for i,a in enumerate(part):
+                for b in part[:i]:
+                    qlow,qhigh=sorted((a['q'],b['q']));thick=a['hi']-a['lo'];depth=qhigh-qlow
+                    if depth<=eps or thick<=eps or thick>depth*2:continue
+                    crosses=[n for n in normal if a['lo']-eps<=n['p']<=a['hi']+eps and n['qlo']<=qlow+eps and n['qhi']>=qhigh-eps]
+                    if crosses:brackets.append(dict(lo=a['lo'],hi=a['hi'],qlo=qlow,qhi=qhigh,ids=[a['record']['index'],b['record']['index'],crosses[0]['record']['index']]))
+        for i,a in enumerate(brackets):
+            if len(brackets)>128:raise ValueError('Jamb-profile hypothesis limit exceeded (128)')
+            for b in brackets[:i]:
+                if abs(a['qlo']-b['qlo'])>eps or abs(a['qhi']-b['qhi'])>eps:continue
+                left,right=sorted((a,b),key=lambda x:x['lo']);lo,hi=left['hi'],right['lo'];depth=a['qhi']-a['qlo']
+                if hi-lo<=2*depth:continue
+                frames.append(dict(lo=lo,hi=hi,qlo=a['qlo'],qhi=a['qhi'],source='inward_ends_of_opposed_jamb_profiles',ids=left['ids']+right['ids']))
+        for frame in frames:
+            lo,hi=frame['lo'],frame['hi'];width=hi-lo;depth=frame['qhi']-frame['qlo'];qcenter=(frame['qlo']+frame['qhi'])/2
+            interior=[p for p in parallel if p['lo']>=lo-depth-eps and p['hi']<=hi+depth+eps and frame['qlo']-eps<=p['q']<=frame['qhi']+eps]
+            partial=[p for p in interior if .25*width<=p['hi']-p['lo']<=.9*width]
+            offset_pair=[]
+            for a in partial:
+                for b in partial:
+                    if a is b or abs(a['q']-b['q'])<=eps:continue
+                    if abs(a['lo']-lo)>depth+eps or abs(b['hi']-hi)>depth+eps:continue
+                    if abs(a['hi']-b['lo'])>depth+eps:continue
+                    middle=(a['hi']+b['lo'])/2
+                    bridges=[n for n in normal if abs(n['p']-middle)<=depth+eps and n['qlo']<=min(a['q'],b['q'])+eps and n['qhi']>=max(a['q'],b['q'])-eps]
+                    if bridges:offset_pair=[a,b];break
+                if offset_pair:break
+            full=[p for p in interior if abs(p['lo']-lo)<=eps and abs(p['hi']-hi)<=eps]
+            if offset_pair:
+                kind='引き違い窓';evidence=['両端の枠内面/内向き端から開口区間を測定','異なる見込位置の左右の戸線と中央の重なり/接続を確認']
+            elif len(full)>=3:
+                kind='フィックス';evidence=['左右の枠内面に接する連続した平行線を3本以上確認','開口全体を連続する線があり、左右にずれた戸線の組は確認されない']
+            else:continue
+            ids=support(rows,u,lo,hi,frame['qlo'],frame['qhi'],2*depth+eps,always=frame['ids'])
+            out.append(hypothesis(kind,width,[point(u,lo,qcenter),point(u,hi,qcenter)],ids,
+                evidence+['内法は枠内側の間隔。全体外形・水切り等の出を幅に含めない'],
+                direction=dict(axis_degrees=math.degrees(math.atan2(u[1],u[0]))%180,
+                    motion='axis_parallel'if kind=='引き違い窓'else 'fixed',handedness=None,inside_outside=None),
+                method=frame['source']))
+    return out

jwwkit/_tategu_geometry.py

@@ -0,0 +1,108 @@
+"""Real-mm geometry primitives for read-only planar-symbol analysis."""
+import math
+
+TAU=2*math.pi
+
+
+def dot(a,b):return a[0]*b[0]+a[1]*b[1]
+def sub(a,b):return (a[0]-b[0],a[1]-b[1])
+def cross(a,b):return a[0]*b[1]-a[1]*b[0]
+def distance(a,b):return math.hypot(a[0]-b[0],a[1]-b[1])
+
+
+def arc_point(r,angle):return (r['center'][0]+r['radius']*math.cos(angle),r['center'][1]+r['radius']*math.sin(angle))
+
+
+def on_arc(r,point,eps):
+    if abs(distance(r['center'],point)-r['radius'])>eps:return False
+    if r['kind']=='CIRCLE':return True
+    a=math.atan2(point[1]-r['center'][1],point[0]-r['center'][0]);s=r['start'];sweep=r['sweep']
+    if sweep<0:s+=sweep;sweep=-sweep
+    return (a-s)%TAU<=sweep+eps/r['radius'] or (s-a)%TAU<=eps/r['radius']
+
+
+def bounds(r):
+    if r['kind']=='LINE':points=[r['a'],r['b']]
+    else:
+        angles=[r['start'],r['start']+r['sweep']]
+        angles.extend(a for a in (0,math.pi/2,math.pi,3*math.pi/2) if on_arc(r,arc_point(r,a),1e-10))
+        points=[arc_point(r,a) for a in angles]
+    return (min(p[0]for p in points),min(p[1]for p in points),max(p[0]for p in points),max(p[1]for p in points))
+
+
+def box(rows):
+    boxes=[r['bbox'] for r in rows]
+    return (min(b[0]for b in boxes),min(b[1]for b in boxes),max(b[2]for b in boxes),max(b[3]for b in boxes))
+
+
+def point_segment(p,a,b):
+    v=sub(b,a);length2=dot(v,v)
+    if not length2:return distance(p,a)
+    t=max(0.,min(1.,dot(sub(p,a),v)/length2))
+    return distance(p,(a[0]+t*v[0],a[1]+t*v[1]))
+
+
+def contacts(a,b,eps):
+    ba,bb=a['bbox'],b['bbox']
+    if ba[2]+eps<bb[0]or bb[2]+eps<ba[0]or ba[3]+eps<bb[1]or bb[3]+eps<ba[1]:return False
+    if a['kind']=='LINE'and b['kind']=='LINE':
+        p,r=a['a'],sub(a['b'],a['a']);q,s=b['a'],sub(b['b'],b['a']);den=cross(r,s)
+        if den:
+            t=cross(sub(q,p),s)/den;u=cross(sub(q,p),r)/den
+            if 0<=t<=1 and 0<=u<=1:return True
+        return min(point_segment(a['a'],b['a'],b['b']),point_segment(a['b'],b['a'],b['b']),
+                   point_segment(b['a'],a['a'],a['b']),point_segment(b['b'],a['a'],a['b']))<=eps
+    if b['kind']=='LINE':a,b=b,a
+    if a['kind']=='LINE':
+        p=a['a'];v=sub(a['b'],p);f=sub(p,b['center']);aa=dot(v,v)
+        if not aa:return on_arc(b,p,eps)
+        if on_arc(b,a['a'],eps)or on_arc(b,a['b'],eps):return True
+        if b['kind']=='ARC' and any(point_segment(arc_point(b,t),a['a'],a['b'])<=eps for t in (b['start'],b['start']+b['sweep'])):return True
+        bb=2*dot(f,v);cc=dot(f,f)-b['radius']**2;discriminant=bb*bb-4*aa*cc
+        if discriminant<0:return False
+        for t in ((-bb-math.sqrt(discriminant))/(2*aa),(-bb+math.sqrt(discriminant))/(2*aa)):
+            if 0<=t<=1 and on_arc(b,(p[0]+t*v[0],p[1]+t*v[1]),eps):return True
+        return False
+    d=distance(a['center'],b['center'])
+    if d<=eps and abs(a['radius']-b['radius'])<=eps:return any(on_arc(b,arc_point(a,t),eps)for t in (a['start'],a['start']+a['sweep']))
+    if d==0 or d>a['radius']+b['radius']+eps or d<abs(a['radius']-b['radius'])-eps:return False
+    x=(a['radius']**2-b['radius']**2+d*d)/(2*d);h2=a['radius']**2-x*x
+    if h2<0:return False
+    u=((b['center'][0]-a['center'][0])/d,(b['center'][1]-a['center'][1])/d)
+    for sign in (-1,1):
+        point=(a['center'][0]+x*u[0]-sign*math.sqrt(h2)*u[1],a['center'][1]+x*u[1]+sign*math.sqrt(h2)*u[0])
+        if on_arc(a,point,eps)and on_arc(b,point,eps):return True
+    return False
+
+
+def components(rows,eps,max_pairs):
+    n=len(rows)
+    if n*(n-1)//2>max_pairs:raise ValueError('Planar recognition contact-pair limit exceeded')
+    parent=list(range(n))
+    def root(i):
+        while parent[i]!=i:parent[i]=parent[parent[i]];i=parent[i]
+        return i
+    for i in range(n):
+        for j in range(i):
+            if contacts(rows[i],rows[j],eps):parent[root(i)]=root(j)
+    groups={}
+    for i,r in enumerate(rows):groups.setdefault(root(i),[]).append(r)
+    return list(groups.values())
+
+
+def real_record(entity,index,scale,marked):
+    g=entity.geometry;kind=entity.entity_type
+    r=dict(index=index,kind=kind,marked=marked,curve_group=entity.attributes['group'])
+    if kind=='LINE':
+        r.update(a=(g['start_x']*scale,g['start_y']*scale),b=(g['end_x']*scale,g['end_y']*scale))
+        if not all(math.isfinite(v)for p in (r['a'],r['b'])for v in p):raise ValueError('Nonfinite line')
+        r['length']=distance(r['a'],r['b'])
+        if not r['length']:raise ValueError('Zero-length line')
+    else:
+        if g['flatness']!=1:raise ValueError('Elliptical symbols are outside the first planar recognizer')
+        r.update(center=(g['center_x']*scale,g['center_y']*scale),radius=g['radius']*scale,
+            start=g['start_angle']+g['tilt_angle'],sweep=TAU if kind=='CIRCLE'else g['arc_angle'])
+        if not all(math.isfinite(v)for v in (*r['center'],r['radius'],r['start'],r['sweep']))or r['radius']<=0 or not 0<abs(r['sweep'])<=TAU:
+            raise ValueError('Unverified circular symbol geometry')
+    r['bbox']=bounds(r)
+    return r

jwwkit/alignment.py

@@ -0,0 +1,85 @@
+"""Two-point alignment in real millimetres; no automatic tolerance or scaling."""
+import math
+
+__all__ = ['solve_two_point_alignment']
+
+
+def _number(value, label):
+    if type(value) not in (int, float) or not math.isfinite(value):
+        raise ValueError(label + ' must be finite numeric')
+    return float(value)
+
+
+def _points(values, label):
+    if not isinstance(values, (tuple, list)) or len(values) != 2:
+        raise ValueError(label + ' requires two points')
+    result = []
+    for p in values:
+        if not isinstance(p, (tuple, list)) or len(p) != 2:
+            raise ValueError(label + ' requires XY pairs')
+        result.append(tuple(_number(x, label) for x in p))
+    return result
+
+
+def solve_two_point_alignment(source_points, target_points, *, distance_tolerance,
+                             angle_tolerance, angle_units='rad', allow_scale=False):
+    """Return fit, both angle units and tolerance verdict without editing.
+
+    Distance tolerance is real mm. Angle tolerance bounds the absolute rotation
+    between the directed pairs, not a post-fit residual. Scaling is opt-in and
+    never bypasses either original-pair tolerance. Coincident pairs are refused.
+    """
+    src = _points(source_points, 'source_points')
+    dst = _points(target_points, 'target_points')
+    dt = _number(distance_tolerance, 'distance_tolerance')
+    at = _number(angle_tolerance, 'angle_tolerance')
+    if angle_units not in ('rad', 'deg'):
+        raise ValueError('angle_units must be rad or deg')
+    if type(allow_scale) is not bool:
+        raise ValueError('allow_scale must be bool')
+    if dt < 0 or at < 0 or at > (math.pi if angle_units == 'rad' else 180):
+        raise ValueError('Invalid tolerance range')
+    ar = at if angle_units == 'rad' else math.radians(at)
+    u = tuple(b-a for a,b in zip(src[0],src[1]))
+    v = tuple(b-a for a,b in zip(dst[0],dst[1]))
+    ls, lt = math.hypot(*u), math.hypot(*v)
+    if not all(math.isfinite(x) for x in (*u,*v,ls,lt)):
+        raise ValueError('Pair span overflow')
+    result = dict(passed=False, reasons=[], source_points_real_mm=src,
+                  target_points_real_mm=dst, source_distance_mm=ls, target_distance_mm=lt,
+                  distance_difference_mm=lt-ls, distance_tolerance_mm=dt,
+                  angle_input_units=angle_units, angle_tolerance_input=at,
+                  angle_tolerance_rad=ar, angle_tolerance_deg=math.degrees(ar),
+                  allow_scale=allow_scale, coordinate_units='real', transform=None)
+    if ls == 0 or lt == 0:
+        result['reasons'] = ['Coincident reference points']
+        return result
+    result.update(angle_tolerance_endpoint_displacement_mm=(2*math.sin(ar/2))*ls,
+                  angle_tolerance_lateral_mm=ls*abs(math.sin(ar)),
+                  angular_offset_baseline_mm=ls,
+                  reference_angle_tolerance_rad=dt/ls,
+                  reference_angle_tolerance_deg=math.degrees(dt/ls))
+    if not all(math.isfinite(result[k]) for k in ('angle_tolerance_endpoint_displacement_mm','angle_tolerance_lateral_mm','reference_angle_tolerance_rad','reference_angle_tolerance_deg')):
+        raise ValueError('Angular tolerance reference amount overflow')
+    ux,uy = u[0]/ls,u[1]/ls
+    vx,vy = v[0]/lt,v[1]/lt
+    angle = math.atan2(ux*vy-uy*vx,ux*vx+uy*vy)
+    ratio = lt/ls
+    if not math.isfinite(ratio) or ratio <= 0:
+        raise ValueError('Scale ratio cannot be represented')
+    scale = ratio if allow_scale else 1.
+    shift = tuple(b-a for a,b in zip(src[0],dst[0]))
+    if not all(math.isfinite(x) for x in shift):
+        raise ValueError('Translation overflow')
+    result.update(angle_difference_rad=angle, angle_difference_deg=math.degrees(angle),
+                  estimated_scale=ratio, applied_scale=scale,
+                  endpoint_residuals_mm=[0., abs(lt-scale*ls)])
+    if abs(lt-ls) > dt:
+        result['reasons'].append('Distance difference exceeds tolerance')
+    if abs(angle) > ar:
+        result['reasons'].append('Angle difference exceeds tolerance')
+    result['passed'] = not result['reasons']
+    if result['passed']:
+        result['transform'] = dict(base_point=src[0], translation=shift,
+                                   rotation=angle, scale_x=scale, scale_y=scale, units='real')
+    return result

jwwkit/cad_model.py

@@ -0,0 +1,5 @@
+"""編集用公開APIの互換窓口。実寸換算・既存図面編集はmodel.documentで管理する。"""
+from jwwkit.model.common_entities import CadEntity, CadBlockDefinition, model_entity
+from jwwkit.model.document import CadDocument
+
+from jwwkit.reader.jws import JwsDocument

jwwkit/cli.py

@@ -0,0 +1,40 @@
+"""Offline command line entry point."""
+import argparse
+import json
+
+from jwwkit import guide_paths
+from jwwkit._commands import (
+    check_installation, compare_drawings, inspect_jwf, recognize_planar_tategu, summarize_drawing,
+)
+
+
+def _check(_args):
+    result = check_installation.check(
+        compare_command="compare",
+        inspect_jwf_command="inspect-jwf",
+        summarize_command="summarize",
+    )
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+
+
+def _guide(_args):
+    for path in guide_paths().values():
+        print(path)
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(prog="jwwkit", description=__doc__)
+    commands = parser.add_subparsers(dest="command", required=True)
+    commands.add_parser("check", help="Check the installed package with synthetic drawings").set_defaults(run=_check)
+    commands.add_parser("guide", help="Print the installed AGENTS.md and usage guide paths").set_defaults(run=_guide)
+    for name, module in (
+        ("summarize", summarize_drawing),
+        ("compare", compare_drawings),
+        ("inspect-jwf", inspect_jwf),
+        ("recognize-tategu", recognize_planar_tategu),
+    ):
+        command = commands.add_parser(name, help=module.__doc__, description=module.__doc__)
+        module.add_arguments(command)
+        command.set_defaults(run=module.run)
+    args = parser.parse_args(argv)
+    return args.run(args)