Edge Intersection Point



  • On 18/06/2015 at 12:49, xxxxxxxx wrote:

    User Information:
    Cinema 4D Version:   16 
    Platform:   Windows  ;   
    Language(s) :     C++  ;

    ---------
    Hello,

    I need to get the intersection point of two edges. Is there a function in the SDK which can handle this? I've searched the SDK but didn't find something useful.

    Or do I have to write my own function?

    Best wishes
    crush4



  • On 19/06/2015 at 01:28, xxxxxxxx wrote:

    You will have to write it yourself. I don't know of any such routine in the api.



  • On 19/06/2015 at 04:26, xxxxxxxx wrote:

    it is quite easy, I remember I wrote or found one somewhere before, here is the function from my code:

      
    template<typename  T>
    struct SNodePoint
    {
    	T x;
    	T y;
      
    	SNodePoint() :
    		x(0), y(0)
    	{}
      
    	SNodePoint(T &_x, T &_y) :
    		x(_x), y(_y)
    	{}
      
    	SNodePoint(const T &_x, const T &_y) :
    		x(_x), y(_y)
    	{}
      
      
      
    	SNodePoint& operator+=(const SNodePoint& rhs)
    	{
    		x = x + rhs.x;
    		y = y + rhs.y;
      
    		return *this;
    	}
      
    	friend SNodePoint operator+(SNodePoint lhs, const SNodePoint& rhs)
    	{
    		return lhs += rhs;
    	}
      
    	SNodePoint& operator-=(const SNodePoint& rhs)
    	{
    		x = x - rhs.x;
    		y = y - rhs.y;
      
    		return *this;
    	}
      
    	friend SNodePoint operator-(SNodePoint lhs, const SNodePoint& rhs)
    	{
    		return lhs -= rhs;
    	}
      
    	SNodePoint& operator*=(const Float32& rhs)
    	{
    		x = x * rhs;
    		y = y * rhs;
      
    		return *this;
    	}
      
    	friend SNodePoint operator*(SNodePoint lhs, const Float32& rhs)
    	{
    		return lhs *= rhs;
    	}
    	
    	friend SNodePoint operator*(Float32 lhs, const SNodePoint& rhs)
    	{
    		return rhs * lhs;
    	}
      
    	SNodePoint& operator/=(const Float32& rhs)
    	{
    		x = x / rhs;
    		y = y / rhs;
      
    		return *this;
    	}
      
    	friend SNodePoint operator/(SNodePoint lhs, const Float32& rhs)
    	{
    		return lhs /= rhs;
    	}
    	
    	friend SNodePoint operator/(Float32 lhs, const SNodePoint& rhs)
    	{
    		return rhs / lhs;
    	}
    };
      
    Bool get_line_intersection(const SNodePoint<Float32> &p0, const SNodePoint<Float32> &p1, 
        const SNodePoint<Float32> &p2, const SNodePoint<Float32> & p3, SNodePoint<Float32> *pi)
    {
        float s02_x, s02_y, s10_x, s10_y, s32_x, s32_y, s_numer, t_numer, denom, t;
        s10_x = p1.x - p0.x;
        s10_y = p1.y - p0.y;
        s32_x = p3.x - p2.x;
        s32_y = p3.y - p2.y;
      
        denom = s10_x * s32_y - s32_x * s10_y;
        if (denom == 0)
            return FALSE; // Collinear
        bool denomPositive = denom > 0;
      
        s02_x = p0.x - p2.x;
        s02_y = p0.y - p2.y;
        s_numer = s10_x * s02_y - s10_y * s02_x;
        if ((s_numer < 0) == denomPositive)
            return FALSE; // No collision
      
        t_numer = s32_x * s02_y - s32_y * s02_x;
        if ((t_numer < 0) == denomPositive)
            return FALSE; // No collision
      
        if (((s_numer > denom) == denomPositive) || ((t_numer > denom) == denomPositive))
            return FALSE; // No collision
        // Collision detected
        t = t_numer / denom;
        if (pi != NULL)
    	{
            pi->x = p0.x + (t * s10_x);
            pi->y = p0.y + (t * s10_y);
    	}
      
        return TRUE;
    }
    


  • On 19/06/2015 at 09:27, xxxxxxxx wrote:

    Thank you Mohamed, but I need it in 3D room. This is a little bit more complicated. But when I finish my code, I will post it here ;)

    Greetz
    crush4


Log in to reply