C++ Hình Họa Không Gian: C++ Rectangle

17 September, 202216 September, 2022 ptpham 40 Views 0 Comments c++ đồ họa, c++ graphics, c++ rect, c++ rectangle 4 min read

Hi, chào mừng các bạn trở lại với chủ đề C++ Hình họa không gian.

Bài hôm nay chúng ta sẽ xây dựng một lớp đối tượng mới, đó là lớp rectangle.

Như vậy khi các bạn đã có point, vector, line rồi, chúng ta có thể tạo ra các lớp đối tượng hình học theo như mong muốn

Và bài hôm nay, tôi sẽ xây dựng lớp rectangle.

1. Lý thuyết cơ bản.

a. Tính chất của rect

Rectangle hay còn gọi là hình chữ nhât có các tính chất cơ bản sau.

– Rect luôn bao gồm 4 điểm => lớp sẽ có 4 point.

– Rect có thể sử dụng 2 điểm để tạo ra 4 điểm còn lại, ví dụ điểm min, max.

– Rect thường là yếu tố hình học đại diện cho vùng bao của một đối tượng hình học khác.

b. Các hàm xử lý cơ bản của Rect.

– Hàm khởi tạo: khởi tạo ban đầu giá trị các điểm.

– Hàm hủy.

– Hàm sét giá trị các điểm.

– Hàm lấy mảng chứa list các điểm.

– Hàm tính diện tích của rect

– Hàm tính chu vi của rect.

– Hàm tính ra điểm trọng tâm của rect.

– Hàm check một điểm nằm bên trong của rect hay bên ngoài rect, hay trên cạnh của rect.

Và các hàm khác các bạn có thể nghĩ ra.

2. Code sample

File header.



#include <vector>
#include "TPoint2D.h"
#include "TLine.h"

class TRect
{
public:
    TRect();
    ~TRect();
    void ChangePoint(TPoint2D& p, int index);
    void SetPoint(TPoint2D* p);
    TPoint2D* GetPoint(int& nSize);
    std::vector<TPoint2D> GetPointList();
    float GetArea();
    float GetPerimiter();
    TPoint2D GetCenterPt();
    
    // Condition: z = 0 (2D)
    // return = -1 => No Define
    // return = 0 => inside
    // return = 1 => in edge
    // return = 2 => outside
    int CheckRelPoint(const TPoint2D& p);
    void GetBounding(TPoint2D& pMin, TPoint2D& pMax);
private:
    TPoint2D m_points[4];
};

#include <vector>

#include "TPoint2D.h"

#include "TLine.h"

class TRect

{

public:

TRect();

~TRect();

void ChangePoint(TPoint2D& p, int index);

void SetPoint(TPoint2D* p);

TPoint2D* GetPoint(int& nSize);

std::vector<TPoint2D> GetPointList();

float GetArea();

float GetPerimiter();

TPoint2D GetCenterPt();

// Condition: z = 0 (2D)

// return = -1 => No Define

// return = 0 => inside

// return = 1 => in edge

// return = 2 => outside

int CheckRelPoint(const TPoint2D& p);

void GetBounding(TPoint2D& pMin, TPoint2D& pMax);

private:

TPoint2D m_points[4];

};

File Cpp



#include "TRect.h"


TRect::TRect()
{
    for (int i = 0; i < 4; i++)
    {
        m_points[i] = TPoint2D(0.0, 0.0);
    }
}


TRect::~TRect()
{

}
void TRect::ChangePoint(TPoint2D& p, int index)
{
    if (index >= 0 && index < 4)
    {
        m_points[index] = p;
    }
}

void TRect::SetPoint(TPoint2D* p)
{
    for (int i = 0; i < 4; i++)
    {
        m_points[i] = *(p + i);
    }
}

TPoint2D* TRect::GetPoint(int& nSize)
{
    nSize = 4;
    return &m_points[0];
}

std::vector<TPoint2D> TRect::GetPointList()
{
    std::vector<TPoint2D> ptList;
    ptList.push_back(m_points[0]);
    ptList.push_back(m_points[1]);
    ptList.push_back(m_points[2]);
    ptList.push_back(m_points[3]);

    return ptList;
}

float TRect::GetArea()
{
    float d1 = m_points[0].GetDistance(m_points[1]);
    float d2 = m_points[1].GetDistance(m_points[2]);
    float s = d1*d2;
    return s;
}

float TRect::GetPerimiter()
{
    float d1 = m_points[0].GetDistance(m_points[1]);
    float d2 = m_points[1].GetDistance(m_points[2]);
    float c = (d1 + d2) * 2;
    return c;
}

TPoint2D TRect::GetCenterPt()
{
    TPoint2D ptMid = m_points[0].GetMidPoint(m_points[2]);
    return ptMid;
}

int TRect::CheckRelPoint(const TPoint2D& p)
{
    bool iret = -1;
    for (int i = 0; i < 4; i++)
    {
        int j = (i + 1) % 4;
        TLine2D line = TLine2D(m_points[i], m_points[j]);
        int ret = line.CheckRelPoint(p);
        if (ret == 0)
        {
            iret = 1; // in line
            return iret;
        }
    }

    int xMin = m_points[0].x_;
    int yMin = m_points[0].y_;
    int xMax = m_points[0].x_;
    int yMax = m_points[0].y_;

    for (int i = 0; i < 4; i++)
    {
        if (xMin > m_points[i].x_)
        {
            xMin = m_points[i].x_;
        }

        if (yMin > m_points[i].y_)
        {
            yMin = m_points[i].y_;
        }

        if (xMax < m_points[i].x_)
        {
            xMax = m_points[i].x_;
        }

        if (yMax < m_points[i].y_)
        {
            yMax = m_points[i].y_;
        }
    }

    if (p.x_ > xMin && p.x_ < xMax &&
        p.y_ > yMin && p.y_ < yMax)
    {
        return 0;
    }
    else
    {
        return 2;
    }

    return -1;
}

void TRect::GetBounding(TPoint2D& pMin, TPoint2D& pMax)
{
    float xmin = m_points[0].x_;
    float ymin = m_points[0].y_;
    float xmax = m_points[0].x_;
    float ymax = m_points[0].y_;

    for (int i = 0; i < 4; i++)
    {
        float x = m_points[i].x_;
        float y = m_points[i].y_;

        if (x > xmax)
        {
            xmax = x;
        }

        if (y > ymax)
        {
            ymax = y;
        }

        if (x < xmin)
        {
            xmin = x;
        }

        if (y < ymin)
        {
            ymin = y;
        }
    }

    pMin.x_ = xmin;
    pMin.y_ = ymin;

    pMax.x_ = xmax;
    pMax.y_ = ymax;

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

#include "TRect.h"

TRect::TRect()

{

for (int i = 0; i < 4; i++)

{

m_points[i] = TPoint2D(0.0, 0.0);

}

TRect::~TRect()

{

}

void TRect::ChangePoint(TPoint2D& p, int index)

{

if (index >= 0 && index < 4)

{

m_points[index] = p;

}

void TRect::SetPoint(TPoint2D* p)

{

for (int i = 0; i < 4; i++)

{

m_points[i] = *(p + i);

}

TPoint2D* TRect::GetPoint(int& nSize)

{

nSize = 4;

return &m_points[0];

}

std::vector<TPoint2D> TRect::GetPointList()

{

std::vector<TPoint2D> ptList;

ptList.push_back(m_points[0]);

ptList.push_back(m_points[1]);

ptList.push_back(m_points[2]);

ptList.push_back(m_points[3]);

return ptList;

}

float TRect::GetArea()

{

float d1 = m_points[0].GetDistance(m_points[1]);

float d2 = m_points[1].GetDistance(m_points[2]);

float s = d1*d2;

return s;

}

float TRect::GetPerimiter()

{

float d1 = m_points[0].GetDistance(m_points[1]);

float d2 = m_points[1].GetDistance(m_points[2]);

float c = (d1 + d2) * 2;

return c;

}

TPoint2D TRect::GetCenterPt()

{

TPoint2D ptMid = m_points[0].GetMidPoint(m_points[2]);

return ptMid;

}

int TRect::CheckRelPoint(const TPoint2D& p)

{

bool iret = -1;

for (int i = 0; i < 4; i++)

{

int j = (i + 1) % 4;

TLine2D line = TLine2D(m_points[i], m_points[j]);

int ret = line.CheckRelPoint(p);

if (ret == 0)

{

iret = 1; // in line

return iret;

}

int xMin = m_points[0].x_;

int yMin = m_points[0].y_;

int xMax = m_points[0].x_;

int yMax = m_points[0].y_;

for (int i = 0; i < 4; i++)

{

if (xMin > m_points[i].x_)

{

xMin = m_points[i].x_;

}

if (yMin > m_points[i].y_)

{

yMin = m_points[i].y_;

}

if (xMax < m_points[i].x_)

{

xMax = m_points[i].x_;

}

if (yMax < m_points[i].y_)

{

yMax = m_points[i].y_;

}

if (p.x_ > xMin && p.x_ < xMax &&

p.y_ > yMin && p.y_ < yMax)

{

return 0;

}

else

{

return 2;

}

return -1;

}

void TRect::GetBounding(TPoint2D& pMin, TPoint2D& pMax)

{

float xmin = m_points[0].x_;

float ymin = m_points[0].y_;

float xmax = m_points[0].x_;

float ymax = m_points[0].y_;

for (int i = 0; i < 4; i++)

{

float x = m_points[i].x_;

float y = m_points[i].y_;

if (x > xmax)

{

xmax = x;

}

if (y > ymax)

{

ymax = y;

}

if (x < xmin)

{

xmin = x;

}

if (y < ymin)

{

ymin = y;

}

pMin.x_ = xmin;

pMin.y_ = ymin;

pMax.x_ = xmax;

pMax.y_ = ymax;

}

Khi độ dài các cạnh là bằng nhau, rect sẽ trở thành một hình vuông. Do đó các bạn có thể sử dụng cho cả hình vuông

Leave a Reply Cancel reply