dimine-python-sdk 0.1.8__py3-none-any.whl

dimine_python_sdk/lib/types/point.py

@@ -0,0 +1,695 @@
+import DmPyBindInterface as Dm
+
+#点
+class Point:
+    """二次封装Point类"""
+    def __init__(self, a: int = 0):
+        """
+        构造函数
+        :param a: 初始化x分量的值，默认0
+        """
+        self._obj = Dm.Point(a)
+
+    # ---------------------- 核心方法封装 ----------------------
+    def get(self) -> int:
+        """
+        获取x分量的值
+        :return: x分量的整数值
+        """
+        return self._obj.get()
+
+    def set(self, a: int) -> None:
+        """
+        设置x分量的值
+        :param a: 新的x分量整数值
+        """
+        self._obj.set(a)
+
+
+class DmDPoint:
+    """双精度点"""
+
+    def __init__(self, x: float = 0.0, y: float = 0.0, z: float = 0.0):
+        """
+        构造函数
+        :param x: 向量x分量，默认0.0
+        :param y: 向量y分量，默认0.0
+        :param z: 向量z分量，默认0.0
+        """
+        self._obj = Dm.dmDPoint(x, y, z)
+
+    @classmethod
+    def _from_obj(cls, obj):
+        """
+        :param obj: 源dmDPoint对象
+        :return: DmDPoint实例
+        """
+        instance = cls()
+        instance._obj = obj
+        return instance
+
+
+    # ---------------------- 分量属性封装 ----------------------
+    @property
+    def x(self) -> float:
+        return self._obj.x
+
+    @x.setter
+    def x(self, value: float):
+        self._obj.x = float(value)
+
+    @property
+    def y(self) -> float:
+        return self._obj.y
+
+    @y.setter
+    def y(self, value: float):
+        self._obj.y = float(value)
+
+    @property
+    def z(self) -> float:
+        return self._obj.z
+
+    @z.setter
+    def z(self, value: float):
+        self._obj.z = float(value)
+
+    # ---------------------- 基础运算符 ----------------------
+    def __add__(self, other: "DmDPoint") -> "DmDPoint":
+        """
+        向量加法
+        :param other: 待相加的DmDPoint实例
+        :return: 相加后的新DmDPoint实例
+        :raise TypeError: 非DmDPoint实例时抛出
+        """
+        if not isinstance(other, DmDPoint):
+            raise TypeError(f"仅支持DmDPoint实例相加，当前为{type(other)}")
+        res = DmDPoint()
+        res._obj = self._obj + other._obj
+        return res
+
+    def __sub__(self, other: "DmDPoint") -> "DmDPoint":
+        """
+        向量减法
+        :param other: 待相减的DmDPoint实例
+        :return: 相减后的新DmDPoint实例
+        :raise TypeError: 非DmDPoint实例时抛出
+        """
+        if not isinstance(other, DmDPoint):
+            raise TypeError(f"仅支持DmDPoint实例相减，当前为{type(other)}")
+        res = DmDPoint()
+        res._obj = self._obj - other._obj
+        return res
+
+    def __mul__(self, scalar: (int, float)) -> "DmDPoint":
+        """
+        向量标量乘法
+        :param scalar: 相乘的标量（int/float）
+        :return: 相乘后的新DmDPoint实例
+        :raise TypeError: 非标量类型时抛出
+        """
+        if not isinstance(scalar, (int, float)):
+            raise TypeError(f"仅支持与标量(int/float)相乘，当前为{type(scalar)}")
+        res = DmDPoint()
+        res._obj = self._obj * scalar
+        return res
+
+    def __truediv__(self, scalar: (int, float)) -> "DmDPoint":
+        """
+        向量标量除法
+        :param scalar: 相除的标量（int/float）
+        :return: 相除后的新DmDPoint实例
+        :raise TypeError: 非标量类型时抛出
+        :raise ZeroDivisionError: 标量为0时抛出
+        """
+        if not isinstance(scalar, (int, float)):
+            raise TypeError(f"仅支持与标量(int/float)相除，当前为{type(scalar)}")
+        if scalar == 0:
+            raise ZeroDivisionError("向量标量除法，标量不能为0")
+        res = DmDPoint()
+        res._obj = self._obj / scalar
+        return res
+
+    # ---------------------- 复合赋值运算符 ----------------------
+    def __iadd__(self, other: "DmDPoint") -> "DmDPoint":
+        """
+        向量加法赋值（原地修改）
+        :param other: 待相加的DmDPoint实例
+        :return: 自身实例（支持链式调用）
+        :raise TypeError: 非DmDPoint实例时抛出
+        """
+        if not isinstance(other, DmDPoint):
+            raise TypeError(f"仅支持DmDPoint实例相加赋值，当前为{type(other)}")
+        self._obj += other._obj
+        return self
+
+    def __isub__(self, other: "DmDPoint") -> "DmDPoint":
+        """
+        向量减法赋值（原地修改）
+        :param other: 待相减的DmDPoint实例
+        :return: 自身实例（支持链式调用）
+        :raise TypeError: 非DmDPoint实例时抛出
+        """
+        if not isinstance(other, DmDPoint):
+            raise TypeError(f"仅支持DmDPoint实例相减赋值，当前为{type(other)}")
+        self._obj -= other._obj
+        return self
+
+    def __imul__(self, scalar: (int, float)) -> "DmDPoint":
+        """
+        向量标量乘法赋值（原地修改）
+        :param scalar: 相乘的标量（int/float）
+        :return: 自身实例（支持链式调用）
+        :raise TypeError: 非标量类型时抛出
+        """
+        if not isinstance(scalar, (int, float)):
+            raise TypeError(f"仅支持与标量(int/float)相乘赋值，当前为{type(scalar)}")
+        self._obj *= scalar
+        return self
+
+    def __itruediv__(self, scalar: (int, float)) -> "DmDPoint":
+        """
+        向量标量除法赋值（原地修改）
+        :param scalar: 相除的标量（int/float）
+        :return: 自身实例（支持链式调用）
+        :raise TypeError: 非标量类型时抛出
+        :raise ZeroDivisionError: 标量为0时抛出
+        """
+        if not isinstance(scalar, (int, float)):
+            raise TypeError(f"仅支持与标量(int/float)相除赋值，当前为{type(scalar)}")
+        if scalar == 0:
+            raise ZeroDivisionError("向量标量除法赋值，标量不能为0")
+        self._obj /= scalar
+        return self
+
+    # ---------------------- 单目/比较运算符 ----------------------
+    def __neg__(self) -> "DmDPoint":
+        """
+        负号运算符（取反向量）
+        :return: 取反后的新DmDPoint实例
+        """
+        res = DmDPoint()
+        res._obj = -self._obj
+        return res
+
+    def __eq__(self, other: "DmDPoint") -> bool:
+        """
+        等于比较运算符
+        :param other: 待比较的DmDPoint实例
+        :return: 相等返回True，否则返回False；非DmDPoint实例直接返回False
+        """
+        if not isinstance(other, DmDPoint):
+            return False
+        return self._obj == other._obj
+
+    def __ne__(self, other: "DmDPoint") -> bool:
+        """
+        不等于比较运算符
+        :param other: 待比较的DmDPoint实例
+        :return: 不相等返回True，否则返回False；非DmDPoint实例直接返回True
+        """
+        if not isinstance(other, DmDPoint):
+            return True
+        return self._obj != other._obj
+
+    # ---------------------- 核心工具方法 ----------------------
+    def __getitem__(self, idx: int) -> float:
+        """
+        索引访问分量（0=x,1=y,2=z)
+        :param idx: 索引值（仅支持0/1/2）
+        :return: 对应索引的分量值（float）
+        :raise IndexError: 索引非整数/超出0-2范围时抛出
+        """
+        if not isinstance(idx, int) or idx < 0 or idx >= 3:
+            raise IndexError("向量索引仅支持0(x)、1(y)、2(z)，超出范围")
+        return self._obj[idx]
+
+    def is_zero_length(self, tol: float = 1e-10) -> bool:
+        """
+        判断是否为零向量（考虑浮点精度误差）
+        :param tol: 浮点容差阈值，默认1e-10（值越小精度要求越高）
+        :return: 向量长度接近0返回True，否则返回False
+
+        example:
+        ```python
+        pt = DmDPoint(0, 0, 0)
+        print(pt.is_zero_length())
+        ```
+        """
+        return self._obj.IsZeroLength(tol)
+
+    def dot_product(self, other: "DmDPoint") -> float:
+        """
+        计算两个向量的点积（数量积）
+        :param other: 待计算点积的DmDPoint实例
+        :return: 点积结果（float）
+        :raise TypeError: 非DmDPoint实例时抛出
+
+        example:
+        ```python
+        pt1 = DmDPoint(1, 2, 3)
+        pt2 = DmDPoint(4, 5, 6)
+        dot = pt1.dot_product(pt2)
+        print(dot)
+        ```
+        """
+        if not isinstance(other, DmDPoint):
+            raise TypeError(f"仅支持与DmDPoint实例计算点积，当前为{type(other)}")
+        return self._obj.DotProduct(other._obj)
+
+    def cross_product(self, other: "DmDPoint") -> "DmDPoint":
+        """
+        计算两个向量的叉积（向量积）
+        :param other: 待计算叉积的DmDPoint实例
+        :return: 叉积结果的新DmDPoint实例
+        :raise TypeError: 非DmDPoint实例时抛出
+
+        example:
+        ```python
+        pt1 = DmDPoint(1, 2, 3)
+        pt2 = DmDPoint(4, 5, 6)
+        cross = pt1.cross_product(pt2)
+        print(cross)
+        ```
+        """
+        if not isinstance(other, DmDPoint):
+            raise TypeError(f"仅支持与DmDPoint实例计算叉积，当前为{type(other)}")
+        res = DmDPoint()
+        res._obj = self._obj.CrossProduct(other._obj)
+        return res
+
+    def norm(self) -> float:
+        """
+        计算向量的模长（长度）
+        :return: 向量模长结果（float）
+
+        example:
+        ```python
+        pt = DmDPoint(3, 4, 0)
+        print(pt.norm())
+        ```
+        """
+        return self._obj.Norm()
+
+    def normalize(self) -> "DmDPoint":
+        """
+        向量归一化（原地修改，转为单位向量）
+        :return: 自身实例
+
+        example:
+        ```python
+        pt = DmDPoint(3, 4, 0)
+        pt.normalize()
+        print(pt)
+        ```
+        """
+        self._obj.Normalize()
+        return self
+
+    def set(self, x: float, y: float, z: float) -> "DmDPoint":
+        """
+        一次性设置向量x/y/z分量（原地修改）
+        :param x: 新的x分量值（float）
+        :param y: 新的y分量值（float）
+        :param z: 新的z分量值（float）
+        :return: 自身实例（支持链式调用）
+
+        example:
+        ```python
+        pt = DmDPoint()
+        pt.set(1, 2, 3)
+        print(pt)  # 输出: (1.0, 2.0, 3.0)
+        ```
+        """
+        self._obj.Set(float(x), float(y), float(z))
+        return self
+
+    # ---------------------- 字符串表示 ----------------------
+    def __repr__(self) -> str:
+        """
+        字符串表示
+        :return: 向量的标准字符串表示
+        """
+        return self._obj.__repr__()
+
+    def __str__(self) -> str:
+        """
+        打印字符串，与__repr__保持一致，确保输出格式统一
+        :return: 向量的打印字符串表示
+        """
+        return self._obj.__repr__()
+
+# class DmSPoint:
+#     """单精度点类"""
+#
+#     def __init__(self, x: float = 0.0, y: float = 0.0, z: float = 0.0):
+#         """
+#         构造函数
+#         :param x: 向量x分量，默认0.0
+#         :param y: 向量y分量，默认0.0
+#         :param z: 向量z分量，默认0.0
+#         """
+#         self._obj = Dm.dmSPoint(x, y, z)
+#
+#     # ---------------------- 分量属性封装 ----------------------
+#     @property
+#     def x(self) -> float:
+#         return self._obj.x
+#
+#     @x.setter
+#     def x(self, value: float):
+#         self._obj.x = float(value)
+#
+#     @property
+#     def y(self) -> float:
+#         return self._obj.y
+#
+#     @y.setter
+#     def y(self, value: float):
+#         self._obj.y = float(value)
+#
+#     @property
+#     def z(self) -> float:
+#         return self._obj.z
+#
+#     @z.setter
+#     def z(self, value: float):
+#         self._obj.z = float(value)
+#
+#     # ---------------------- 基础运算符 ----------------------
+#     def __add__(self, other: "DmSPoint") -> "DmSPoint":
+#         """
+#         向量加法
+#         :param other: 待相加的DmSPoint实例
+#         :return: 相加后的新DmSPoint实例
+#         :raise TypeError: 非DmSPoint实例时抛出
+#         """
+#         if not isinstance(other, DmSPoint):
+#             raise TypeError(f"仅支持DmSPoint实例相加，当前为{type(other)}")
+#         res = DmSPoint()
+#         res._obj = self._obj + other._obj
+#         return res
+#
+#     def __sub__(self, other: "DmSPoint") -> "DmSPoint":
+#         """
+#         向量减法
+#         :param other: 待相减的DmSPoint实例
+#         :return: 相减后的新DmSPoint实例
+#         :raise TypeError: 非DmSPoint实例时抛出
+#         """
+#         if not isinstance(other, DmSPoint):
+#             raise TypeError(f"仅支持DmSPoint实例相减，当前为{type(other)}")
+#         res = DmSPoint()
+#         res._obj = self._obj - other._obj
+#         return res
+#
+#     def __mul__(self, scalar: (int, float)) -> "DmSPoint":
+#         """
+#         向量标量乘法
+#         :param scalar: 相乘的标量（int/float）
+#         :return: 相乘后的新DmSPoint实例
+#         :raise TypeError: 非标量类型时抛出
+#         """
+#         if not isinstance(scalar, (int, float)):
+#             raise TypeError(f"仅支持与标量(int/float)相乘，当前为{type(scalar)}")
+#         res = DmSPoint()
+#         res._obj = self._obj * scalar
+#         return res
+#
+#     def __truediv__(self, scalar: (int, float)) -> "DmSPoint":
+#         """
+#         向量标量除法
+#         :param scalar: 相除的标量（int/float）
+#         :return: 相除后的新DmSPoint实例
+#         :raise TypeError: 非标量类型时抛出
+#         :raise ZeroDivisionError: 标量为0时抛出
+#         """
+#         if not isinstance(scalar, (int, float)):
+#             raise TypeError(f"仅支持与标量(int/float)相除，当前为{type(scalar)}")
+#         if scalar == 0:
+#             raise ZeroDivisionError("向量标量除法，标量不能为0")
+#         res = DmSPoint()
+#         res._obj = self._obj / scalar
+#         return res
+#
+#     # ---------------------- 复合赋值运算符 ----------------------
+#     def __iadd__(self, other: "DmSPoint") -> "DmSPoint":
+#         """
+#         向量加法赋值
+#         :param other: 待相加的DmSPoint实例
+#         :return: 自身实例（支持链式调用）
+#         :raise TypeError: 非DmSPoint实例时抛出
+#         """
+#         if not isinstance(other, DmSPoint):
+#             raise TypeError(f"仅支持DmSPoint实例相加赋值，当前为{type(other)}")
+#         self._obj += other._obj
+#         return self
+#
+#     def __isub__(self, other: "DmSPoint") -> "DmSPoint":
+#         """
+#         向量减法赋值
+#         :param other: 待相减的DmSPoint实例
+#         :return: 自身实例（支持链式调用）
+#         :raise TypeError: 非DmSPoint实例时抛出
+#         """
+#         if not isinstance(other, DmSPoint):
+#             raise TypeError(f"仅支持DmSPoint实例相减赋值，当前为{type(other)}")
+#         self._obj -= other._obj
+#         return self
+#
+#     def __imul__(self, scalar: (int, float)) -> "DmSPoint":
+#         """
+#         向量标量乘法赋值
+#         :param scalar: 相乘的标量（int/float）
+#         :return: 自身实例（支持链式调用）
+#         :raise TypeError: 非标量类型时抛出
+#         """
+#         if not isinstance(scalar, (int, float)):
+#             raise TypeError(f"仅支持与标量(int/float)相乘赋值，当前为{type(scalar)}")
+#         self._obj *= scalar
+#         return self
+#
+#     def __itruediv__(self, scalar: (int, float)) -> "DmSPoint":
+#         """
+#         向量标量除法赋值
+#         :param scalar: 相除的标量（int/float）
+#         :return: 自身实例（支持链式调用）
+#         :raise TypeError: 非标量类型时抛出
+#         :raise ZeroDivisionError: 标量为0时抛出
+#         """
+#         if not isinstance(scalar, (int, float)):
+#             raise TypeError(f"仅支持与标量(int/float)相除赋值，当前为{type(scalar)}")
+#         if scalar == 0:
+#             raise ZeroDivisionError("向量标量除法赋值，标量不能为0")
+#         self._obj /= scalar
+#         return self
+#
+#     # ---------------------- 单目/比较运算符 ----------------------
+#     def __neg__(self) -> "DmSPoint":
+#         """
+#         负号运算符（取反向量）
+#         :return: 取反后的新DmSPoint实例
+#         """
+#         res = DmSPoint()
+#         res._obj = -self._obj
+#         return res
+#
+#     def __eq__(self, other: "DmSPoint") -> bool:
+#         """
+#         等于比较运算符
+#         :param other: 待比较的DmSPoint实例
+#         :return: 分量均在容差内相等返回True，否则返回False
+#         """
+#         if not isinstance(other, DmSPoint):
+#             return False
+#         return self._obj == other._obj
+#
+#     def __ne__(self, other: "DmSPoint") -> bool:
+#         """
+#         不等于比较运算符
+#         :param other: 待比较的DmSPoint实例
+#         :return: 任意分量在容差外不等返回True，否则返回False
+#         """
+#         if not isinstance(other, DmSPoint):
+#             return True
+#         return self._obj != other._obj
+#
+#     # ---------------------- 核心工具方法（小写+下划线规范） ----------------------
+#     def dot_product(self, other: "DmSPoint") -> float:
+#         """
+#         计算两个向量的点积（数量积）
+#         :param other: 待计算点积的DmSPoint实例
+#         :return: 点积结果（float）
+#         :raise TypeError: 非DmSPoint实例时抛出
+#         """
+#         if not isinstance(other, DmSPoint):
+#             raise TypeError(f"仅支持与DmSPoint实例计算点积，当前为{type(other)}")
+#         return self._obj.DotProduct(other._obj)
+#
+#     def cross_product(self, other: "DmSPoint") -> "DmSPoint":
+#         """
+#         计算两个向量的叉积（向量积）
+#         :param other: 待计算叉积的DmSPoint实例
+#         :return: 叉积结果的新DmSPoint实例
+#         :raise TypeError: 非DmSPoint实例时抛出
+#         """
+#         if not isinstance(other, DmSPoint):
+#             raise TypeError(f"仅支持与DmSPoint实例计算叉积，当前为{type(other)}")
+#         res = DmSPoint()
+#         res._obj = self._obj.CrossProduct(other._obj)
+#         return res
+#
+#     def norm(self) -> float:
+#         """
+#         计算向量的模长（长度的平方开根）
+#         :return: 向量模长结果（float）
+#         """
+#         return self._obj.Norm()
+#
+#     def __getitem__(self, idx: int) -> float:
+#         """
+#         索引访问分量（0=x,1=y,2=z）
+#         :param idx: 索引值（仅支持0/1/2）
+#         :return: 对应索引的分量值（float）
+#         :raise IndexError: 索引非整数/超出0-2范围时抛出
+#         """
+#         if not isinstance(idx, int) or idx < 0 or idx >= 3:
+#             raise IndexError("向量索引仅支持0(x)、1(y)、2(z)，超出范围")
+#         return self._obj[idx]
+#
+#     def is_zero_length(self, tol: float = 1e-10) -> bool:
+#         """
+#         判断是否为零向量（考虑浮点精度误差）
+#         :param tol: 浮点容差阈值，默认1e-10（值越小精度要求越高）
+#         :return: 向量长度接近0返回True，否则返回False
+#         """
+#         return self._obj.IsZeroLength(tol)
+#
+#     def normalize(self) -> "DmSPoint":
+#         """
+#         向量归一化（原地修改，转为单位向量）
+#         :return: 自身实例（支持链式调用）
+#         """
+#         self._obj.Normalize()
+#         return self
+#
+#     # ---------------------- 字符串表示 ----------------------
+#     def __repr__(self) -> str:
+#         """
+#         字符串表示
+#         :return: 向量的标准字符串表示
+#         """
+#         return self._obj.__repr__()
+#
+#     def __str__(self) -> str:
+#         """
+#         打印字符串，与__repr__保持一致
+#         :return: 向量的打印字符串表示
+#         """
+#         return self._obj.__repr__()
+
+#点集
+class DmPoints:
+    """点集类"""
+
+    def __init__(self):
+        """
+        构造函数：初始化点集合对象
+        :return: None
+        """
+        self._obj = Dm.dmPoints()
+
+    def insert_point(self, point: DmDPoint, point_id: int) -> None:
+        """
+        插入一个点并指定ID,ID不连续则会在中间插入[0,0,0]
+        :param point: 待插入的点（DmDPoint实例）
+        :param point_id: 点的唯一ID（整数）
+
+        example:
+        ```python
+        points = DmPoints()
+        points.insert_point(DmDPoint(1, 2, 3), 0)
+        ```
+        """
+        self._obj.InsertPoint(point._obj, point_id)
+
+    def insert_next_point(self, point: DmDPoint) -> int:
+        """
+        插入下一个点，自动分配ID
+        :param point: 待插入的点（DmDPoint实例）
+        :return: 自动分配的点索引（整数）
+
+        example:
+        ```python
+        points = DmPoints()
+        point_id = points.insert_next_point(DmDPoint(1, 2, 3))
+        ```
+        """
+        return self._obj.InsertNextPoint(point._obj)
+
+    def get_point_data_list(self) -> list[DmDPoint]:
+        """
+        获取所有点的坐标数据
+        :return: 点列表，每个元素为DmDPoint实例
+
+        example:
+        ```python
+        points = DmPoints()
+        points.insert_point(DmDPoint(1, 2, 3), 0)
+        points.insert_point(DmDPoint(4, 5, 6), 1)
+        point_list = points.get_point_data_list()
+        for point in point_list:
+            print(point)
+        ```
+        """
+        cpp_list = self._obj.GetPointData()
+        return [DmDPoint._from_obj(item) for item in cpp_list]
+
+    def __repr__(self) -> str:
+        """
+        字符串表示（直接调用源端实现，包含点数量和坐标）
+        :return: 点集合的标准字符串表示
+        """
+        return self._obj.__repr__()
+
+    @classmethod
+    def _from_obj(cls, obj):
+        """
+        :param obj: 原生dmPoints对象
+        :return: DmPoints实例
+        """
+        instance = cls.__new__(cls)
+        instance._obj = obj
+        return instance
+
+#点实体
+class DmDbPoint:
+    """点实体"""
+    def __init__(self):
+        """构造函数，初始化数据库点对象"""
+        self._obj = Dm.dmDbPoint()
+
+    def get_graph_data(self) -> DmDPoint:
+        """
+        获取该点的图形数据（坐标信息）
+        :return: 点的坐标（DmDPoint实例）
+
+        example:
+        ```python
+        if entity.get_type() == ETT_POINT:
+            graph_data = entity.get_graph_data()
+            print(graph_data)
+        ```
+        """
+        cpp_result = self._obj.GetGraphData()
+        return DmDPoint._from_obj(cpp_result)
+
+    @classmethod
+    def _from_obj(cls, obj):
+        """
+        :param obj: 原生dmDbPoint对象
+        :return: DmDbPoint实例
+        """
+        instance = cls.__new__(cls)
+        instance._obj = obj
+        return instance

dimine_python_sdk/logger.py

@@ -0,0 +1,7 @@
+import logging
+import os,sys
+
+LOG_FORMAT = "%(asctime)s %(levelname)s[%(filename)s:%(lineno)d] %(message)s"
+logging.basicConfig(level=os.environ.get("DA_LOG_LEVEL", "INFO"), format=LOG_FORMAT)
+
+logger = logging.getLogger(__name__)

dimine_python_sdk/models/__init__.py

@@ -0,0 +1,3 @@
+from .conn import *
+from .errors import *
+from .types import *