当前位置： 首页 > article >正文

6 齐次坐标模块（homogen.rs）

article 2025/2/1 10:07:59

homogen.rs代码定义了一个名为 HomogeneousVector 的结构体，它是用于表示三维空间中的齐次向量。齐次向量常用于计算机图形学和几何学中，特别是在处理投影和变换时。下面是对这段代码的详细解释和一些关键的代码片段分析：

一、homogen.rs文件源码

use crate::point::{Point2D, Point3D};
use crate::vector::{Vector2D, Vector3D};

use crate::num::{One, Zero};

#[cfg(feature = "bytemuck")]
use bytemuck::{Pod, Zeroable};
use core::cmp::{Eq, PartialEq};
use core::fmt;
use core::hash::Hash;
use core::marker::PhantomData;
use core::ops::Div;
#[cfg(feature = "serde")]
use serde;

/// Homogeneous vector in 3D space.
#[repr(C)]
pub struct HomogeneousVector<T, U> {
    pub x: T,
    pub y: T,
    pub z: T,
    pub w: T,
    #[doc(hidden)]
    pub _unit: PhantomData<U>,
}

impl<T: Copy, U> Copy for HomogeneousVector<T, U> {}

impl<T: Clone, U> Clone for HomogeneousVector<T, U> {
    fn clone(&self) -> Self {
        HomogeneousVector {
            x: self.x.clone(),
            y: self.y.clone(),
            z: self.z.clone(),
            w: self.w.clone(),
            _unit: PhantomData,
        }
    }
}

#[cfg(feature = "serde")]
impl<'de, T, U> serde::Deserialize<'de> for HomogeneousVector<T, U>
where
    T: serde::Deserialize<'de>,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let (x, y, z, w) = serde::Deserialize::deserialize(deserializer)?;
        Ok(HomogeneousVector {
            x,
            y,
            z,
            w,
            _unit: PhantomData,
        })
    }
}

#[cfg(feature = "serde")]
impl<T, U> serde::Serialize for HomogeneousVector<T, U>
where
    T: serde::Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        (&self.x, &self.y, &self.z, &self.w).serialize(serializer)
    }
}

#[cfg(feature = "arbitrary")]
impl<'a, T, U> arbitrary::Arbitrary<'a> for HomogeneousVector<T, U>
where
    T: arbitrary::Arbitrary<'a>,
{
    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
        let (x, y, z, w) = arbitrary::Arbitrary::arbitrary(u)?;
        Ok(HomogeneousVector {
            x,
            y,
            z,
            w,
            _unit: PhantomData,
        })
    }
}

#[cfg(feature = "bytemuck")]
unsafe impl<T: Zeroable, U> Zeroable for HomogeneousVector<T, U> {}

#[cfg(feature = "bytemuck")]
unsafe impl<T: Pod, U: 'static> Pod for HomogeneousVector<T, U> {}

impl<T, U> Eq for HomogeneousVector<T, U> where T: Eq {}

impl<T, U> PartialEq for HomogeneousVector<T, U>
where
    T: PartialEq,
{
    fn eq(&self, other: &Self) -> bool {
        self.x == other.x && self.y == other.y && self.z == other.z && self.w == other.w
    }
}

impl<T, U> Hash for HomogeneousVector<T, U>
where
    T: Hash,
{
    fn hash<H: core::hash::Hasher>(&self, h: &mut H) {
        self.x.hash(h);
        self.y.hash(h);
        self.z.hash(h);
        self.w.hash(h);
    }
}

impl<T, U> HomogeneousVector<T, U> {
    /// Constructor taking scalar values directly.
    #[inline]
    pub const fn new(x: T, y: T, z: T, w: T) -> Self {
        HomogeneousVector {
            x,
            y,
            z,
            w,
            _unit: PhantomData,
        }
    }
}

impl<T: Copy + Div<T, Output = T> + Zero + PartialOrd, U> HomogeneousVector<T, U> {
    /// Convert into Cartesian 2D point.
    ///
    /// Returns `None` if the point is on or behind the W=0 hemisphere.
    #[inline]
    pub fn to_point2d(self) -> Option<Point2D<T, U>> {
        if self.w > T::zero() {
            Some(Point2D::new(self.x / self.w, self.y / self.w))
        } else {
            None
        }
    }

    /// Convert into Cartesian 3D point.
    ///
    /// Returns `None` if the point is on or behind the W=0 hemisphere.
    #[inline]
    pub fn to_point3d(self) -> Option<Point3D<T, U>> {
        if self.w > T::zero() {
            Some(Point3D::new(
                self.x / self.w,
                self.y / self.w,
                self.z / self.w,
            ))
        } else {
            None
        }
    }
}

impl<T: Zero, U> From<Vector2D<T, U>> for HomogeneousVector<T, U> {
    #[inline]
    fn from(v: Vector2D<T, U>) -> Self {
        HomogeneousVector::new(v.x, v.y, T::zero(), T::zero())
    }
}

impl<T: Zero, U> From<Vector3D<T, U>> for HomogeneousVector<T, U> {
    #[inline]
    fn from(v: Vector3D<T, U>) -> Self {
        HomogeneousVector::new(v.x, v.y, v.z, T::zero())
    }
}

impl<T: Zero + One, U> From<Point2D<T, U>> for HomogeneousVector<T, U> {
    #[inline]
    fn from(p: Point2D<T, U>) -> Self {
        HomogeneousVector::new(p.x, p.y, T::zero(), T::one())
    }
}

impl<T: One, U> From<Point3D<T, U>> for HomogeneousVector<T, U> {
    #[inline]
    fn from(p: Point3D<T, U>) -> Self {
        HomogeneousVector::new(p.x, p.y, p.z, T::one())
    }
}

impl<T: fmt::Debug, U> fmt::Debug for HomogeneousVector<T, U> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_tuple("")
            .field(&self.x)
            .field(&self.y)
            .field(&self.z)
            .field(&self.w)
            .finish()
    }
}

#[cfg(test)]
mod homogeneous {
    use super::HomogeneousVector;
    use crate::default::{Point2D, Point3D};

    #[test]
    fn roundtrip() {
        assert_eq!(
            Some(Point2D::new(1.0, 2.0)),
            HomogeneousVector::from(Point2D::new(1.0, 2.0)).to_point2d()
        );
        assert_eq!(
            Some(Point3D::new(1.0, -2.0, 0.1)),
            HomogeneousVector::from(Point3D::new(1.0, -2.0, 0.1)).to_point3d()
        );
    }

    #[test]
    fn negative() {
        assert_eq!(
            None,
            HomogeneousVector::<f32, ()>::new(1.0, 2.0, 3.0, 0.0).to_point2d()
        );
        assert_eq!(
            None,
            HomogeneousVector::<f32, ()>::new(1.0, -2.0, -3.0, -2.0).to_point3d()
        );
    }
}

二、结构体定义

#[repr(C)]
pub struct HomogeneousVector<T, U> {
    pub x: T,
    pub y: T,
    pub z: T,
    pub w: T,
    #[doc(hidden)]
    pub _unit: PhantomData<U>,
}
  • #[repr©] 属性确保了结构体在内存中的布局是连续的，这对于与C语言接口或者特定的内存对齐需求很有用。
  • T 是向量的坐标类型，它可以是任何数值类型，比如 f32 或 f64。
  • U 是一个类型参数，通过 PhantomData 被引入，通常用于表示一些与结构体相关的额外信息，比如单位或维度，但不占用实际的内存空间。
  • _unit 字段被标记为文档隐藏，意味着在生成的文档中不会显示这个字段。

三、实现特性

  • Copy 和 Clone：由于 HomogeneousVector 持有的是泛型 T，只有当 T 实现 Copy 或 Clone 时，HomogeneousVector 才能相应地实现 Copy 或 Clone。
  • serde 序列化/反序列化：当启用了 serde 功能时，HomogeneousVector 可以被序列化和反序列化，前提是它的类型参数 T 也支持 serde。
  • From 实现：提供了从 Vector2D、Vector3D、Point2D 和 Point3D 到 HomogeneousVector 的转换方法。这些转换方法将源数据转换为齐次坐标形式，例如，二维点转换为齐次坐标时，w 分量被设置为 1，而 z 分量（对于2D点来说不存在）被设置为 0。

四、示例代码片段分析

从 Vector2D 转换到 HomogeneousVector

impl<T: Zero, U> From<Vector2D<T, U>> for HomogeneousVector<T, U> {
    #[inline]
    fn from(v: Vector2D<T, U>) -> Self {
        HomogeneousVector::new(v.x, v.y, T::zero(), T::zero())
    }
}

这里假设 Vector2D 是一个二维向量结构体，T::zero() 返回类型 T 的零值。此实现将二维向量的 x 和 y 分量转换为齐次向量的前两个分量，并将 z 和 w 分量都设置为零。

调试输出

impl<T: fmt::Debug, U> fmt::Debug for HomogeneousVector<T, U> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_tuple("")
            .field(&self.x)
            .field(&self.y)
            .field(&self.z)
            .field(&self.w)
            .finish()
    }
}

当 T 实现了 fmt::Debug 时，HomogeneousVector 也可以被格式化输出，这通常用于调试目的。

五、总结

homogen.rs代码展示了如何在 Rust 中定义和实现一个泛型结构体，以及如何利用 Rust 的类型系统和特性（如 PhantomData、条件编译 #[cfg()]、特性标志等）来增强代码的功能性和灵活性。HomogeneousVector 的设计使其能够灵活地与不同的数值类型和额外的类型信息一起工作，同时支持序列化和从其他几何类型转换。


http://www.kler.cn/a/526998.html

相关文章：

  • Python从0到100（八十六）：神经网络-ShuffleNet通道混合轻量级网络的深入介绍
  • 20个整流电路及仿真实验汇总
  • 一文讲解Java中的异常处理机制
  • ODP(OBProxy)路由初探
  • Android createScaledBitmap与Canvas通过RectF drawBitmap生成马赛克/高斯模糊（毛玻璃）对比，Kotlin
  • CAG技术：提升LLM响应速度与质量
  • Spring框架IOC依赖注入功能详细使用指南
  • java_自定义异常
  • 350.两个数组的交集 ②
  • SSM开发(九) mybatis多表查询(举例说明)
  • Python3 【装饰器】水平考试和答案
  • 复杂场景使用xpath定位元素
  • 计算机网络 笔记 网络层 3
  • C++ deque（1）
  • 元旦和春节取名的历史变迁
  • ESP32-S3模组上跑通esp32-camera（38）
  • 嵌入式系统|DMA和SPI
  • GitHub上传文件异常 显示this file is hidden
  • 《苍穹外卖》项目学习记录-Day7缓存套餐
  • 1 HDFS
  • 深入解析 COUNT(DISTINCT) OVER(ORDER BY)：原理、问题与高效替代方案
  • Visual Studio使用GitHub Copilot提高.NET开发工作效率
  • Day50：字典的合并
  • nodejs：express + js-mdict 网页查询英汉词典
  • 算法基础——存储
  • 智能小区物业管理系统推动数字化转型与提升用户居住体验