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

Hi. chào mừng các bạn đến với chủ đề: c++ hình họa không gian

Không biết là các bạn có đủ kiên nhẫn để theo đến bài này hay không.

Bài hôm nay tối sẽ cùng các bạn nghiên cứu về một đối tượng kết hợp.

Đó là xây dựng lớp đối tượng Grid

 

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

a. Đặc điểm của 1 Grid.

Grid là lưới, nó là một đối tượng thực tế và trong hình học nó là đối tượng được tạo bởi sự kết hợp giữa các line.

Grid được sử dụng phổ biến rộng rãi trong mô phỏng đồ họa, lập trình đồ họa.

Ở đây chúng ta đang nói đến grid dạng rect, chưa nói đến grid custom(grid cho circle, grid cho polygon)

Khi xây dựng lớp đối tượng grid, chúng ta sẽ cần.

1. Điểm đặt của grid. Có thể đặt tại điểm top-left, hoặc điểm tại tâm tùy cách thiết kế.

2. Chiều dài, chiều rộng của grid.

3. Độ rộng của cell, mỗi ô trong grid sẽ có độ dài rộng là bao nhiêu.

4. Nếu không dùng biến độ rộng, thì có thể dùng biến số lượng. (chia grid thành bao nhiêu line dọc, line ngang.

– Nếu theo tính chất 4, thì ko còn khái niệm độ rộng cell nữa, mà sẽ chia đều độ dài grid cho số lượng line dọc.(ngang tương tự)

– Nếu theo tính chất 3, thì cứ chia theo độ rộng cell, còn thiếu bao nhiêu thì chấp nhận.

 

b. Các hàm xử lý của grid.

Hàm khởi tạo, hủy dữ liệu.

Hàm set/get điểm đặt, chiều dài, rộng grid, số lượng line hoặc độ rộng cell.

Hàm vẽ ra grid từ dữ liệu nhập vào, bằng tạo ra các line.

Tính diện tích grid/ chu vi grid.

Check 1 điểm nằm trong vùng grid, hay trên biên, hay ngoài vùng.

2. Code Sample

File header.

#ifndef TGRID_H_
#define TGRID_H_

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

class TGrid
{
public:
    TGrid();
    ~TGrid();

    enum PosType
    {
        GRID_LEFT_TOP = 0,
        GRID_RIGHT_TOP = 1,
        GRID_RIGHT_BOT = 2,
        GRID_LEFT_BOT = 3,
        GRID_CENTER = 4,
    };

    void SetInfo(float length, float width, int wNum, int hNum)
    {
        m_length - length;
        m_width = width;
        m_lNum = hNum;
        m_wNum = wNum;
    }

    void SetLength(float l) { m_length = l; }
    void SetWidth(float w) 
    { 
        m_width = w; 
    };
    void SetWNum(int wn) { m_wNum = wn; };
    void SetHNum(int hn) { m_lNum = hn; }

    float GetLength() { return m_length; }
    float GetWidth() { return m_width; }
    float GetWNum() { return m_wNum; }
    float GetHNum() { return m_lNum; }
    int GetType() const { return m_PosType; }
    float GetWCell();
    float GetHCell();

    void MakeData();
    void SetType(int type) { m_PosType = type; }
    void SetPos(const TPoint2D& pt) { m_point = pt; }
    TPoint2D GetPos() { return m_point; }

    std::vector<TLine2D*> GetXLines() { return m_XLines; }
    std::vector<TLine2D*> GetYLines() { return m_YLines; }
private:
    float m_length;
    float m_width;
    int m_wNum;      // width cell num
    int m_lNum;      // height cell num
    int m_PosType;
    TPoint2D m_point;

    std::vector<TLine2D*> m_XLines;
    std::vector<TLine2D*> m_YLines;
};

#endif

 

File cpp

#include "TGrid.h"


TGrid::TGrid()
{
    m_length = 0.0;
    m_wNum = 0.0;
    m_wNum = 0;
    m_lNum = 0;
    m_PosType = GRID_LEFT_TOP;
    m_point = TPoint2D(0.0, 0.0);

}


TGrid::~TGrid()
{

}


float TGrid::GetWCell()
{
    float wcell = 0.0;

    return wcell;
}

float TGrid::GetHCell()
{
    float hcell = 0.0;

    return hcell;
}

void TGrid::MakeData()
{
    float lCell = m_length / m_lNum;
    float wCell = m_width / m_wNum;
    TVector2D vX;
    TVector2D vY;
    TPoint2D basePoint = m_point;
    if (m_PosType == GRID_LEFT_TOP)
    {
        vX = TVector2D(1.0, 0.0);
        vY = TVector2D(0.0, 1.0);
    }
    else if (m_PosType == GRID_RIGHT_TOP)
    {
        vX = TVector2D(-1.0, 0.0);
        vY = TVector2D(0.0, 1.0);
    }
    else if (m_PosType == GRID_RIGHT_BOT)
    {
        vX = TVector2D(-1.0, 0.0);
        vY = TVector2D(0.0, -1.0);
    }
    else if (m_PosType == GRID_LEFT_BOT)
    {
        vX = TVector2D(1.0, 0.0);
        vY = TVector2D(0.0, -1.0);
    }
    else
    {
        TVector2D vMoveX = TVector2D(-1.0, 0.0);
        TVector2D vMoveY = TVector2D(0.0, 1.0);
        TPoint2D p1 = m_point.GetPointDis(vMoveX, m_length*0.5);

        basePoint = p1.GetPointDis(vMoveY, m_width*0.5);
        vX = TVector2D(1.0, 0.0);
        vY = TVector2D(0.0, -1.0);
    }

    // get xLines;
    for (int i = 0; i <= m_lNum; i++)
    {
        TPoint2D p1 = basePoint.GetPointDis(vX, i*lCell);
        TPoint2D p2 = p1.GetPointDis(vY, m_width);

        TLine2D* pLine = new TLine2D(p1, p2);
        m_XLines.push_back(pLine);
    }

    // get yLines;
    for (int i = 0; i <= m_wNum; i++)
    {
        TPoint2D p1 = basePoint.GetPointDis(vY, i*wCell);
        TPoint2D p2 = p1.GetPointDis(vX, m_length);

        TLine2D* pLine = new TLine2D(p1, p2);
        m_YLines.push_back(pLine);
    }

}

Ok. Đó là grid được mô hình hóa bởi c++