【实验九 模板】

最新推荐文章于 2024-10-06 14:38:37 发布
最新推荐文章于 2024-10-06 14:38:37 发布
阅读量234 收藏
点赞数 1
文章标签： 图像处理 c++ c语言 矩阵
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63438506/article/details/125110289
版权

文章目录

前言

一、实验目的

掌握类模板的定义和使用.

二、实验内容

1.内容

在之前的实验中，我们定义了一个矩阵类Matrix和其子类图像类Image。在数据的存储和处理过程中，我们用过unsigned char和double类型的data指针获取矩阵元素或者图像像素的值。但是现实中的矩阵或者图像数据并不仅仅使用浮点类型和8bits的无符号整数类型，比如有的单反相机可以拍摄32bits无符号整数像素值的图像（unsigned int）；在图像处理中经常将图像灰度值缩放到区间[0,1]内的浮点数（double）；再比如对图像进行傅里叶变换后，得到是复数。因此矩阵的数据类型可以有很多变化。为了实现代码的重用，现在我们使用类模板重构之前的类。

要求：

  1. 定义类模板Mat描述矩阵，矩阵元素的数据类型可以是任意类型，即二级指针data所指向的数据类型采用模板技术进行泛化。
  2. 参考之前的实验，实现Mat类模板的构造函数、析构函数、拷贝构造函数、运算符重载等各种函数。
  3. 使用“引用计数”机制，实现Mat对象间的“浅拷贝”和“浅赋值”。
  4. 实现该类模板的ReadBMP，WriteBMP等函数。在存储图像文件时，像素值一般选取 unsigned char类型（这也是我们前面实验使用该类型的原因）。但是我们的Mat模板类的数据范围不局限于此，因此需要在这两个函数体内完成数据类型转换操作。即把矩阵的元素转换成[0,255]区间内的整数，然后才能保存成BMP文件。通常的做法是计算所有矩阵元素的最大值和最小值，在WriteBMP函数内将对应的数据分别赋成255和0，其它中间的数据转换成0和255之间的无符号8bit整数。这么做仅仅是为了存储时迁就图片文件的格式要求，丢失了原来数据的精度。
  5. ReadText和WriteText函数把数据写入文本文件，这两个函数在实现时需要特别注意，思考如何才能把不同类型的数据合理在文本文件中写入和读取。先自行设计解决方案，更好的办法在实验10中实现。
  6. 定义成员函数Normalize，该函数返回以double特化的模板类对象，该对象将调用者的数据缩放到[0,1]区间。
  7. 将实验8的滤波器类进行模板化重构，能够适用于Mat类模板。

主函数中实现：

  1. 读入图像文件，并将数据缩放到[0,1]区间
  2. 将图像取反色，并输出显示。
  3. 获取矩阵中某个元素的值。
  4. 对矩阵进行旋转、缩放、裁剪、reshape等操作。
  5. 对矩阵进行加减等操作。
  6. 对矩阵进行滤波，显示并保存成图像文件。
  7. 计算原矩阵和滤波后矩阵的差，并把结果保存。

2.代码示例

代码如下（示例）：
Mat.hpp

template< typename T>
class Mat
{
public:
Mat(); //无参数的构造函数，创建行列都为零的Mat对象
    Mat(int h, int w); //构造函数重载，创建h行，w列的Mat对象
    Mat(int h, int w, T val); //构造函数重载，矩阵元素的值都为val;
    Mat(const char* ImageName); //构造函数重载，利用文件名从硬盘加载图像文件成为Mat对象;
    Mat(T **m, int h, int w); //构造函数重载，从动态数组创建Mat对象;
Mat(const Mat &m); //拷贝构造函数;
virtual ~Mat(); //析构函数;

    void ReadBMP(const char *ImageName); //从硬盘文件中读入图像数据
void WriteBMP(const char *filename); //将数据保存为图像文件
// 下面2个读写文本文件的函数，需要考虑不同数据类型的存储
void ReadText(const char *ImageName); //从文本文件中读入数据
void WriteText(const char *filename); //将数据保存为文本文件

int Height();//得到矩阵高度
int Height() const;//得到矩阵高度
int Width();//得到矩阵宽度
int Width() const;//得到矩阵宽度

T Min(); //得到矩阵元素的最小值
T Min() const; //得到矩阵元素的最小值
T Max(); //得到矩阵元素的最大值
T Max() const; //得到矩阵元素的最大值
	
T& At(int row, int col);          //获取某点的值
const T& At(int row, int col) const;  //获取某点的值，const重载
void Set(int row, int col, T value); //设置元素(row,col)为某值;
void Set(T value); //设置所有元素为同一值;

void Flip(int code); //翻转; 根据code的值：0:左右翻转，1:上下翻转;
void Resize(int h, int w); //缩放
    void Crop(int x1, int y1, int x2, int y2);//裁剪点(x1,y1)到点(x2,y2)
void Rotate(int degree);//旋转，90度的整数倍
void Transpose(); // 转置
void Reshape(int h, int w); //在元素总数不变的情况下，将矩阵的行列变为参数给定的大小
bool IsEmpty();// 判断是否为空矩阵
bool IsSquare();// 判断矩阵是否为方阵
Mat<T>  MajorDiagonal();// 求主对角线上的元素，输出一个N行1列的矩阵，N为主对角线上元素的个数
Mat<T>  MinorDiagonal();// 求副对角线上的元素，输出一个N行1列的矩阵，N为副对角线上元素的个数
Mat<T> Row(int n);// 返回矩阵的第n行上的元素，组出一个1行N列的矩阵输出，N为第n行上元素的个数
Mat<T> Column(int n);// 返回矩阵的第n列上的元素，组出一个N行1列的矩阵输出，N为第n列上元素的个数
void Cat(Mat<T> &m, int code); // 将m与当前对象进行拼接，code代表拼接的方式
	void CopyTo(Mat<T> &m); // 将矩阵复制给m，完成深拷贝
    Mat<T> Clone(); // 从当前对象拷贝创建一个新的矩阵，完成深拷贝

Mat<double>  void Normalize();//将矩阵元素的值变换到0-1范围内，以double类型的Mat对象输出。注意：在这个函数里，无法访问Mat<double>类型的对象的私有成员data，需要调用其At函数获得某个元素。

Mat<T>& operator=(const Mat<T> &m);  //重载赋值运算符，完成对象间的拷贝；
bool operator==(const Mat<T> &m);  //判断两个Mat对象是否相等
friend Mat<T> operator+(const Mat<T> &lhs, const Mat<T> &rhs);  //对应元素的数值相加；
friend Mat<T> operator-(const Mat<T> &lhs, const Mat<T> &rhs);  //对应元素的数值相减；
Mat<T>& operator++();  //前置自加；
    Mat<T>& operator--();  //前置自减；
    Mat<T> operator ++(int);  //后置自加；
Mat<T> operator --(int);  //后置自减；
Mat<double> operator-();  // 取反；注意要把矩阵的数据规整到[0,1]区间后，再用1减

friend Mat<T> operator+(Mat<T> &m, T num); //所有元素加上同一数值;
friend Mat<T> operator-(Mat<T> &m, T num); //所有元素减去同一数值;
friend Mat<T> operator*(Mat<T> &m, T num); //所有元素乘上同一数值;
friend Mat<T> operator/(Mat<T> &m, T num); //所有元素除以同一数值;
//另外，用友元函数再写出一个T类型的数和一个Mat对象的加,减,乘,除

Mat<T> gray2bw(T t); //以给定阈值t进行二值化，返回结果对象

friend void Swap(Mat<T> &a, Mat<T> &b);//使用友元函数交换两个Mat对象

private:
// 自己实现一个结构体，来存储矩阵的行数、列数、引用计数和数据指针
// 这里需要声明指向该结构体的指针作为数据成员
};

Filter.hpp
//Filter类

template <class T>
class Filter
{
public:
Filter(int size); //构造函数
virtual ~Filter(); //析构函数;
virtual Mat<T> Filtering(const Mat<T> &input) = 0; //滤波函数（纯虚函数）;
protected:
int filterSize;
};

//meanFilter类
template <class T>
class MeanFilter : public Filter<T>
{
public:
MeanFilter(int size);
virtual ~MeanFilter();
virtual Mat<T> Filtering(const Mat<T> &input); //均值滤波函数
};


//median类
template <class T>
class MedianFilter : public Filter<T>
{
public:
MedianFilter(int size);
virtual ~MedianFilter();
virtual Mat<T> Filtering(const Mat<T> &input); // 中值滤波器函数
};

3.实验要求及说明

完成上述代码以及main函数，验证并实现以上方法。
注意：类模板的头文件，我们以“hpp”作为文件扩展名。Mat类模板和Filter类模板（包括其子类模板）的所有实现代码都放在它们的hpp文件里，即声明和实现放在一起，不将实现代码单独放在cpp文件。

注意：
在Filter和它的两个派生类模板的代码实现过程中，会出现在派生类模板的成员函数里无法使用父类模板里定义的成员变量，比如在MeanFilter的Filtering函数里使用filterSize，编译器会报错，找不到这个变量。这是因为我们写的继承关系发生在类模板之间，而不是实例化后的真正的类之间，编译器无法去推断父类模板里的成员，需要你显式指出该成员来自哪里。有两种解决办法，在派生类模板中这样使用：
Filter::filterSize 或者 this->filterSize
具体可以查找网上相关的资料，比如：
https://blog.csdn.net/sb985/article/details/79670881

以上均为老师给的实验内容，实现如下。

三、代码实现

Main.cpp

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<cstdio>
#include<Windows.h>
#include"Mat.hpp"
#include"Filter.hpp"

using namespace std;
int main()
{
	Mat <double,unsigned char>img1("Fruits_480x511.bmp");
	img1.WriteBMP("img1.bmp");//测试写
	Mat <double,unsigned char>img2("scene2_fg.bmp");
	img2.Normalize().WriteBMP("img2Normalize.bmp");//测试Normalize
	img2.operator-();
	img2.WriteBMP("img2operator-.bmp");//取反
	cout << "获取元素值为：" << img2.At(5, 5) << endl;//获取元素值
	img1.Rotate(180);//旋转
	img1.WriteBMP("img1Rotate.bmp");
	img1.Resize(400, 400);//缩放
	img1.WriteBMP("img1Resize.bmp");
	img1.Reshape(480,512);//转置
	img1.WriteBMP("img1Reshape.bmp");
	img1.Crop(1, 1, 400, 400);//裁剪
	img1.WriteBMP("img1Crop.bmp");
	Mat<double,unsigned char>img3("Airplane.bmp");
	Mat<double,unsigned char>img4("Baboon.bmp");
	img3.Cat(img4, 1);//矩阵拼接
	img3.WriteBMP("img3Cat.bmp");
	img1 + 10;//矩阵加值
	img1.WriteBMP("img1+10.bmp");
	img1 - 10;//矩阵减值
	img1.WriteBMP("img1-10.bmp");
	Mat<int,unsigned char>img5("Lena_gaussian.bmp");//滤波器
	Mat<int, unsigned char>img6("Lena_salt_and_pepper.bmp");
	Filter<int,unsigned char>* filter = NULL;
	filter = new MedianFilter<int,unsigned char>(5);
	img6 = filter->Filtering(img5);
	img6.WriteBMP("img5MedianFilter.bmp");
	img6 = filter->Filtering(img5);
	img6.WriteBMP("img5MeanFilter.bmp");
	return 0;
}

Mat.hpp

#ifndef MAT_HPP
#define MAT_HPP

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<cstdio>
#include<Windows.h>
#include<cstdlib>
#include<cassert>
using namespace std;

template< class T,class T1>
class Mat
{
public://实现和声明在一块写
    void all(int h, int w)
    {
        ptr->height = h;
        ptr->width = w;
        ptr->data = new T * [h];
        for (int i = 0; i < h; i++)
        {
            ptr->data[i] = new T[ptr->width];
        }
    }
    Mat() //无参数的构造函数，创建行列都为零的Mat对象
    {
        ptr = (struct Databack*)malloc(sizeof(struct Databack));
        ptr->refcnt = 1;
    }
    Mat(int h, int w) //构造函数重载，创建h行，w列的Mat对象
    {
        ptr = (struct Databack*)malloc(sizeof(struct Databack));
        ptr->height = h;
        ptr->width = w;
        ptr->data = new T* [ptr->height];
        for (int i = 0; i < ptr->height; i++)
        {
            ptr->data[i] = new T[ptr->width];
        }
        ptr->refcnt=1;
    }
    Mat(int h, int w, T val) //构造函数重载，矩阵元素的值都为val;
    {
        ptr->height = h;
        ptr->width = w;
        for (int i = 0; i < ptr->height; i++)
        {
            for (int j = 0; j < ptr->width; j++)
            {
                ptr->data[i][j] = val;
            }
        }
        ptr->refcnt=1;
    }
    Mat(const char* ImageName) //构造函数重载，利用文件名从硬盘加载图像文件成为Mat对象;
    {
        ptr = (struct Databack*)malloc(sizeof(struct Databack));
        ReadBMP(ImageName);
        ptr->refcnt = 1;
    }
    Mat(T** m, int h, int w) //构造函数重载，从动态数组创建Mat对象;
    {
        ptr->height = h;
        ptr->width = w;
        for (int i = 0; i < ptr->height; i++)
        {
            for (int j = 0; j < ptr->width; j++)
            {
                ptr->data[i][j] = m[i][j];
            }
        }
    }
    Mat(const Mat& m) //拷贝构造函数;
    {
        ptr = (struct Databack*)malloc(sizeof(struct Databack));
        ptr->height = m.ptr->height;
        ptr->width = m.ptr->width;
        ptr->data = new T*[ptr->height];
        for (int i = 0; i < ptr->height; i++)
        {
            ptr->data[i] = new T[ptr->width];
            for (int j = 0; j < ptr->width; j++)
            {
                this->ptr->data[i][j] = m.ptr->data[i][j];
            }
        }
        ptr->refcnt = m.ptr->refcnt;
        ptr->refcnt++;
    }
    virtual ~Mat() //析构函数;
    {
        ptr->refcnt--;
        if (ptr->refcnt == 0)
        {
            for (int i = 0; i < ptr->height; i++)
            {
                delete[]ptr->data[i];
            }
            delete[]ptr->data;
        }
    }

    void ReadBMP(const char* ImageName) //从硬盘文件中读入图像数据
    {
        FILE* fp = fopen(ImageName, "rb");
        if (fp == NULL)
        {
            cout << "文件打开失败！" << endl;
            exit(0);
        }
        BITMAPFILEHEADER fh;
        BITMAPINFOHEADER ih;
        fread(&fh, sizeof(BITMAPFILEHEADER), 1, fp);
        fread(&ih, sizeof(BITMAPINFOHEADER), 1, fp);
        ptr->width = ih.biWidth;
        ptr->height = ih.biHeight;
        if (ptr->height % 4 != 0)
        {
            ptr->height = (ptr->height * (ih.biBitCount) / 8 + 3) / 4 * 4;
            ptr->height = ptr->height / 3;
        }
        if (ptr->width % 4 != 0)
        {
            ptr->width = (ptr->width * (ih.biBitCount) / 8 + 3) / 4 * 4;
            ptr->width = ptr->width / 3;
        }
        ptr->data = new T * [ptr->height];
        for (int i = 0; i < ptr->height; i++)
        {
            ptr->data[i] = new T[ptr->width];
            for (int j = 0; j < ptr->width; j++)
            {
                T1 r, g, b;
                fread(&r, sizeof(T1), 1, fp);
                fread(&g, sizeof(T1), 1, fp);
                fread(&b, sizeof(T1), 1, fp);
                ptr->data[i][j] = static_cast<T>(r / 3 + g / 3 + b / 3);
            }
        }
        fclose(fp);
    }
    void WriteBMP(const char* filename) //将数据保存为图像文件
    {
        FILE* fp = fopen(filename, "wb");
        if (fp == NULL)
        {
            cout << "文件写入失败！" << endl;
            exit(0);
        }
        BITMAPFILEHEADER fh;
        BITMAPINFOHEADER ih;
        fh.bfOffBits = 54;
        fh.bfReserved1 = 0;
        fh.bfReserved2 = 0;
        fh.bfSize = ptr->height * ptr->width * 3 + 54;
        fh.bfType = 19778;
        ih.biBitCount = 24;
        ih.biCompression = 0;
        ih.biXPelsPerMeter = 0;
        ih.biYPelsPerMeter = 0;
        ih.biClrImportant = 0;
        ih.biSize = 40;
        ih.biPlanes = 1;
        ih.biClrUsed = 0;
        ih.biWidth = ptr->width;
        ih.biHeight = ptr->height;
        ih.biSizeImage = ih.biWidth * ih.biHeight * 3;
        fwrite(&fh, sizeof(BITMAPFILEHEADER), 1, fp);
        fwrite(&ih, sizeof(BITMAPINFOHEADER), 1, fp);
        T1 t = 0;
        for (int i = 0; i < ptr->height; i++)
        {
            for (int j = 0; j < ptr->width; j++)
            {
                t = static_cast<T1>(ptr->data[i][j]);
                for (int k = 0; k < 3; k++)
                {
                    fwrite(&t, sizeof(T1), 1, fp);
                }
            }
        }
        fclose(fp);
    }
    // 下面2个读写文本文件的函数，需要考虑不同数据类型的存储
    void ReadText(const char* ImageName) //从文本文件中读入数据
    {
        FILE* fp;
        if (fp = fopen(ImageName, "rb") == 0)
        {
            cout << "文件打开失败！" << endl;
            exit(0);
        }
        BITMAPFILEHEADER fh;
        BITMAPINFOHEADER ih;
        fread(&fh, sizeof(BITMAPFILEHEADER), 1, fp);
        fread(&ih, sizeof(BITMAPINFOHEADER), 1, fp);
        ptr->heigh = ih.biHeight;
        ptr->width = ih.biWidth;
        if (ptr->height % 4 != 0)
        {
            ptr->height = (ptr->height * (ih.biBitCount) / 8 + 3) / 4 * 4;
            ptr->height = ptr->height / 3;
        }
        if (ptr->width % 4 != 0)
        {
            ptr->width = (ptr->width * (ih.biWidth) / 8 + 3) / 4 * 4;
            ptr->width = ptr->width / 3;
        }
        ptr->data= new T*[ptr->height];
        for (int i = 0; i < ptr->height; i++)
        {
            ptr->data[i] = new T [ptr->width];
            for (int j = 0; j < ptr->width; j++)
            {
                T1 r, g, b;
                fread(&r, sizeof(T1), 1, fp);
                fread(&g, sizeof(T1), 1, fp);
                fread(&b, sizeof(T1), 1, fp);
                ptr->data[i][j] = static_cast<T>(r + g + b) / 3;
            }
        }
        fclose(fp);
    }
    void WriteText(const char* filename) //将数据保存为文本文件
    {
        FILE* fp = fopen(filename, "wb");
        if (fp == NULL)
        {
            cout << "文件写入失败！" << endl;
            exit(0);
        }
        BITMAPFILEHEADER fh;
        BITMAPINFOHEADER ih;
        fh.bfOffBits = 54;
        fh.bfReserved1 = 0;
        fh.bfReserved2 = 0;
        fh.bfSize = ptr->height * ptr->width * 3 + 54;
        fh.bfType = 19778;
        ih.biBitCount = 24;
        ih.biCompression = 0;
        ih.biXPelsPerMeter = 0;
        ih.biYPelsPerMeter = 0;
        ih.biClrImportant = 0;
        ih.biSize = 40;
        ih.biPlanes = 1;
        ih.biClrUsed = 0;
        ih.biWidth = ptr->width;
        ih.biHeight = ptr->height;
        ih.biSizeImage = ih.biWidth * ih.biHeight * 3;
        fwrite(&fh, sizeof(BITMAPFILEHEADER), 1, fp);
        fwrite(&ih, sizeof(BITMAPINFOHEADER), 1, fp);
        T1 t = 0;
        for (int i = 0; i < ptr->height; i++)
        {
            for (int j = 0; j < ptr->width; j++)
            {
                t = static_cast<T1>(ptr->data[i][j]);
                for (int k = 0; k < 3; k++)
                {
                    fwrite(&t, sizeof(T1), 1, fp);
                }
            }
        }
        fclose(fp);
    }

    int Height()//得到矩阵高度
    {
        return ptr->height;
    }
    int Height() const//得到矩阵高度
    {
        return ptr->height;
    }
    int Width()//得到矩阵宽度
    {
        return ptr->width;
    }
    int Width() const//得到矩阵宽度
    {
        return ptr->width;
    }

    T Min() //得到矩阵元素的最小值
    {
       T min = ptr->data[0][0];
       for (int i =0; i < ptr->height; i++)
        {
            for (int j = 0; j < ptr->width; j++)
            {
                min < ptr->data[i][j] ? min : ptr->data[i][j];
            }
        }
    }
    T Min() const //得到矩阵元素的最小值
    {
        T min = ptr->data[0][0];
        for (int i = 0; i < ptr->height; i++)
        {
            for (int j = 0; j < ptr->width; j++)
            {
                min < ptr->data[i][j] ? min : ptr->data[i][j];
            }
        }
    }
    T Max() //得到矩阵元素的最大值
    {
        T max = ptr->data[0][0];
        for (int i = 0; i < ptr->height; i++)
        {
            for (int j = 0; j < ptr->width; j++)
            {
                max > ptr->data[i][j] ? max: ptr->data[i][j];
            }
        }
    }
    T Max() const//得到矩阵元素的最大值
    {
        T max = ptr->data[0][0];
        for (int i = 0; i < ptr->height; i++)
        {
            for (int j = 0; j < ptr->width; j++)
            {
                max > ptr->data[i][j] ? max : ptr->data[i][j];
            }
        }
    }

    T& At(int row, int col)          //获取某点的值
    {
        return ptr->data[row][col];
    }
    const T& At(int row, int col) const  //获取某点的值，const重载
    {
        return ptr->data[row - 1][col - 1];
    }
    void Set(int row, int col, T value) //设置元素(row,col)为某值;
    {
        ptr->data[row - 1][col - 1] = value;
    }
    void Set(T value) //设置所有元素为同一值;
    {
        for (int i = 0; i < ptr->height; i++)
        {
            for (int j = 0; j < ptr->width; j++)
            {
                ptr->data[i][j] = value;
            }
        }
    }

    void Flip(int code) //翻转; 根据code的值：0:左右翻转，1:上下翻转;
    {
        T1** t;
        t = new T1* [ptr->height];
        for (int j = 0; j < ptr->height; j++)
        {
            t[j] = new T1[ptr->width];
        }
        if (code == 0)
        {
            for (int i = 0; i < ptr->height; i++)
            {
                for (int j = 0; j < ptr->width; j++)
                {
                    t[i][j] = ptr->data[i][ptr->width - 1 - j];
                }
            }
            for (int i = 0; i < ptr->height; i++)
            {
                for (int j = 0; j < ptr->width; j++)
                {
                    ptr->data[i][j] = t[i][j];
                }
            }
            cout << "左右翻转成功！请查看！" << endl;
        }
        else if (code == 1)
        {
            for (int i = 0; i < ptr->height; i++)
            {
                for (int j = 0; j < ptr->width; j++)
                {
                    t[i][j] = ptr->data[ptr->height - 1 - i][j];
                }
            }
            for (int i = 0; i < ptr->height; i++)
            {
                for (int j = 0; j < ptr->width; j++)
                {
                    ptr->data[i][j] = t[i][j];
                }
            }
            cout << "上下翻转成功！请查看！" << endl;
        }
        for (int i = 0; i < ptr->height; i++)
        {
            delete[]t[i];
        }
        delete[]t;
    }
    void Resize(int h, int w) //缩放
    {
        int oldh = h;
        int oldw = w;
        int oldwidth =ptr-> width;
        int oldheight = ptr->height;
        //新值与原值的差值
        int dw = static_cast<int>(fabs(oldwidth - w));
        int dh = static_cast<int>(fabs(oldheight - h));
        if (dw < 1)//防止dw == 0
        {
            dw = 1;
        }
        if (dh < 1)
        {
            dh = 1;
        }
        int maxw = w > oldwidth ? w : oldwidth;
        int maxh = h > oldheight ? h : oldheight;
        int difw = maxw / dw;
        int difh = maxh / dh;
        T** mdata = new T* [h];
        for (int i = 0, prii = 0; i < h; i++)
        {
            mdata[i] = new T[w];
            if ((i + 1) % difh == 0)
            {
                if (h < oldheight)
                {
                    prii++;
                }
                else
                {
                    continue;
                }
            }
            for (int j = 0, prij = 0; j < w; j++)
            {
                if ((j + 1) % difw == 0)
                {
                    if (w < oldwidth)
                    {
                        prij++;
                    }
                    else
                    {
                        continue;
                    }
                }
                mdata[i][j] = ptr->data[prii][prij];
                if (prij < oldwidth - 1)
                    prij++;
            }
            if (prii < oldheight - 1)
                prii++;
        }
        //填充跳过的指定增行/列
        if (w > oldwidth)//填充列
        {
            for (int i = 0; i < h; i++)
            {
                for (int j = 0; j < w; j++)
                {
                    if ((j + 1) % difw == 0)
                    {
                        mdata[i][j] = mdata[i][j - 1];//指定 增 列填充
                    }
                }
            }
        }

        if (h > oldheight)//填充行
        {
            for (int i = 0; i < h; i++)
            {
                if ((i + 1) % difh == 0)//指定 增 行填充
                {
                    for (int j = 0; j < w; j++)
                    {
                        mdata[i][j] = mdata[i - 1][j];
                    }
                }
            }
        }
        ptr->data = mdata;
        ptr->height = h;
       ptr->width = w;
        cout << "文件缩放成功！" << endl;
    }
    void Crop(int x1, int y1, int x2, int y2)//裁剪点(x1,y1)到点(x2,y2)
    {
        ptr->height = static_cast<T>(fabs(y2 - y1) + 1);
        ptr->width = static_cast<T>(fabs(x2 - x1) + 1);
        T** t;
        t = new T* [ptr->height];
        for (int i = 0; i < ptr->height; i++)
        {
            t[i] = new T[ptr->width];
        }
        for (int i = 0; i < ptr->height; i++)
        {
            for (int j = 0; j < ptr->width; j++)
            {
                t[i][j] = ptr->data[y1 + i-1][x1 + j-1];
            }
        }
        ptr->data = new T* [ptr->height];
        for (int i = 0; i < ptr->height; i++)
        {
            ptr->data[i] = new T[ptr->width];
            for (int j = 0; j < ptr->width; j++)
            {
                ptr->data[i][j] = t[i][j];
            }
        }
        for (int i = 0; i < ptr->height; i++)
        {
            delete[]t[i];
        }
        delete[]t;
        cout << "文件剪裁成功!请查看" << endl;
    }
    void Rotate(int degree)//旋转，90度的整数倍
    {
        int m;
        T** t = nullptr;
        degree = fabs(degree / 90);
        if (degree == 1)
        {
            t = new T * [ptr->width];
            for (int i = 0; i < ptr->width; i++)
            {
                t[i] = new T [ptr->height];
            }
            for (int i = 0; i < ptr->height; i++)
            {
                for (int j = 0; j < ptr->width; j++)
                {
                    t[j][ptr->height - 1 - i] = ptr->data[i][j];
                }
            }
            ptr->data = new T* [ptr->width];
            for (int i = 0; i < ptr->width; i++)
            {
                ptr->data[i] = new T[ptr->height];
            }
            for (int i = 0; i < ptr->width; i++)
            {
                for (int j = 0; j < ptr->height; j++)
                {
                    ptr->data[i][j] = t[i][j];
                }
            }
            m = ptr->height;
            ptr->height = ptr->width;
            ptr->width = m;
            for (int i = 0; i < ptr->width; i++)
            {
                delete[]t[i];
            }
            delete[]t;
        }
        else if (degree == 2)
        {
            t = new T* [ptr->height];
            for (int i = 0; i <ptr->height; i++)
            {
                t[i] = new T[ptr->width];
            }
            for (int i = 0; i < ptr->height; i++)
            {
                for (int j = 0; j < ptr->width; j++)
                {
                    t[ptr->height - 1 - i][j] = ptr->data[i][j];
                }
            }
            for (int i = 0; i < ptr->height; i++)
            {
                for (int j = 0; j < ptr->width; j++)
                {
                   ptr->data[i][j] = t[i][j];
                }
            }
            for (int i = 0; i < ptr->height; i++)
            {
                delete[]t[i];
            }
            delete[]t;
        }
        else if (degree == 3)
        {
            t = new T* [ptr->width];
            for (int i = 0; i < ptr->width; i++)
            {
                t[i] = new T[ptr->height];
            }
            for (int i = 0; i < ptr->height; i++)
            {
                for (int j = 0; j < ptr->width; j++)
                {
                    t[j][i] = ptr->data[i][j];
                }
            }
            ptr->data= new T* [ptr->width];
            for (int i = 0; i <ptr-> width; i++)
            {
                ptr->data[i] = new T[ptr->height];
            }
            m = ptr->height;
            ptr->height = ptr->width;
            ptr->width = m;
            for (int i = 0; i < ptr->height; i++)
            {
                for (int j = 0; j < ptr->width; j++)
                {
                    ptr->data[i][j] = t[i][j];
                }
            }
            for (int i = 0; i < ptr->width; i++)
            {
                delete[]t[i];
            }
            delete[]t;
        }
        cout << "文件旋转成功！请查看！" << endl;
    }
    void Transpose() // 转置
    {
        T** t;
        t = new T* [ptr->width];
        for (int i = 0; i < ptr->width; i++)
        {
            t[i] = new T[ptr->height];
        }
        for (int i = 0; i < ptr->height; i++)
        {
            for (int j = 0; j < ptr->width; j++)
            {
                t[j][i] = ptr->data[i][j];
            }
        }
        for (int i = 0; i < ptr->height; i++)
        {
            delete[]ptr->data[i];
        }
        delete[]ptr->data;
        ptr->data = t;
        int h = ptr->height;
        ptr->height = ptr->width;
        ptr->width = h;
    }
    void Reshape(int h, int w) //在元素总数不变的情况下，将矩阵的行列变为参数给定的大小
    {
        if (h * w == ptr->height * ptr->width)
        {
            long long k = 0;
            T* m = new T[h * w + 1];
            for (int i = 0; i < h; i++)
            {
                for (int j = 0; j < w; j++)
                {
                    if (k < h * w)
                    {
                        m[k] = ptr->data[i][j];
                        k++;
                    }
                }
            }
            k = 0;
            all(h, w);
            for (int i = 0; i < h; i++)
            {
                for (int j = 0; j < w; j++)
                {
                    if (k < h * w)
                    {
                        ptr->data[i][j] = m[k];
                        k++;
                    }
                }
            }
        }
        else cout << "不符合改变条件！" << endl;
    }
    bool IsEmpty()// 判断是否为空矩阵
    {
        T sum = 0;
        for (int i = 0; i < ptr->height; i++)
        {
            for (int j = 0; j < ptr->width; j++)
            {
                sum = sum + ptr->data[i][j];
            }
        }
        if (sum == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    bool IsSquare()// 判断矩阵是否为方阵
    {
        if (ptr->height == ptr->width)
        {
            return true;
        }
        else return false;
    }
    Mat<T,T1>  MajorDiagonal()// 求主对角线上的元素，输出一个N行1列的矩阵，N为主对角线上元素的个数
    {
        int n;
        n = ptr->width < ptr->height ? ptr->width : ptr->height;
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (i == j)
                {
                    cout << ptr->data[i][j] << "/t";
                }
            }
            cout << endl;
        }
    }
    Mat<T,T1>  MinorDiagonal()// 求副对角线上的元素，输出一个N行1列的矩阵，N为副对角线上元素的个数
    {
        int n;
        n = ptr->width < ptr->height ? ptr->width : ptr->height;
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (i == n - j - 1)
                {
                    cout << ptr->data[i][j] << "/t";
                }
            }
            cout << endl;
        }
    }
    Mat<T,T1> Row(int n)// 返回矩阵的第n行上的元素，组出一个1行N列的矩阵输出，N为第n行上元素的个数
    {
        for (int j = 0; j < ptr->width; j++)
        {
            cout << ptr->data[n - 1][j] << "/t";
        }
        return ptr->data[n - 1][0];
    }
    Mat<T,T1> Column(int n)// 返回矩阵的第n列上的元素，组出一个N行1列的矩阵输出，N为第n列上元素的个数
    {
        for (int i = 0; i < ptr->height; i++)
        {
            cout << ptr->data[i][n - 1] << endl;
        }
        return ptr->data[0][n - 1];
    }
    void Cat(Mat<T,T1>& m, int code) // 将m与当前对象进行拼接，code代表拼接的方式
    {
        int h, w;
        int k = 0;
        T** t;
        t = new T* [ptr->height];
        for (int i = 0; i < ptr->height; i++)
        {
            t[i] = new T[ptr->width];
            for (int j = 0; j < ptr->width; j++)
            {
                t[i][j] = ptr->data[i][j];
            }
        }
        if (code == 1)//    左右拼接
        {
            for (int i = 0; i < ptr->height; i++)
            {
                delete[]ptr->data[i];
            }
            delete[]ptr->data;
            w = ptr->width;
            ptr->width += m.ptr->width;
            all(ptr->height, ptr->width);
            //ptr->data = new T* [ptr->height];
            for (int i = 0; i < ptr->height; i++)
            {
                //ptr->data[i] = new T[ptr->width];
                for (int j = 0; j < ptr->width; j++)
                {
                    if (j < w)
                    {
                        ptr->data[i][j] = t[i][j];
                    }
                    else
                    {
                        ptr->data[i][j] = m.ptr->data[i][j - w];
                    }
                }
            }
        }
        else//上下拼接
        {
            h = ptr->height;
            ptr->height = ptr->height + m.ptr->height;
            ptr->data = new T* [ptr->height];
            for (int i = 0; i < ptr->height; i++)
            {
                ptr->data[i] = new T[ptr->width];
                for (int j = 0; j < ptr->width; j++)
                {
                    if (i < h)
                    {
                        ptr->data[i][j] = t[i][j];
                    }
                    else
                    {
                        ptr->data[i][j] = m.ptr->data[i - h][j];
                    }
                }
            }
        }
        cout << "文件拼接成功！" << endl;
    }
    void CopyTo(Mat<T,T1>& m)// 将矩阵复制给m，完成深拷贝
    {
        m.ptr->height=ptr->height;
        m.ptr->width = ptr->width;
        m.ptr->data = new T * [ptr->height];
        for (int i = 0; i < ptr->height; i++)
        {
            ptr->data[i] = new T[ptr->width];
            for (int j = 0; j < ptr->width; j++)
            {
               m.ptr->data[i][j] =ptr->data[i][j];
            }
        }
    }
    Mat<T,T1> Clone() // 从当前对象拷贝创建一个新的矩阵，完成深拷贝
    {
        Mat<T,T1> m(ptr->height,ptr->width);
        m.ptr->height = ptr->height;
        m.ptr->width = ptr->width;
        m.ptr->data = new T * [ptr->height];
        for (int i = 0; i < ptr->height; i++)
        {
            ptr->data[i] = new T[ptr->width];
            for (int j = 0; j < ptr->width; j++)
            {
                m.ptr->data[i][j] = ptr->data[i][j];
            }
        }
        return m;
    }
    Mat<double,T1> Normalize()//将矩阵元素的值变换到0-1范围内，以double类型的Mat对象输出。注意：在这个函数里，无法访问Mat<double>类型的对象的私有成员data，需要调用其At函数获得某个元素。
    {
        Mat<double,T1> m(ptr->height,ptr->width);
        double max = static_cast<double>(this->At(1, 1)), min =static_cast<double> (this->At(1, 1));
        for (int i = 0; i < this->Height(); i++)
        {
            for (int j = 0; j < this->Width(); j++)
            {
                max = max > static_cast<double>(this->At(i, j)) ? max : static_cast<double>(this->At(i, j));
                min = min < static_cast<double>(this->At(i, j))? min : static_cast<double>(this->At(i, j));
            }
        }
        for (int i = 0; i < static_cast<double>(this->Height()); i++)
        {
            for (int j = 0; j < static_cast<double>(this->Width()); j++)
            {
                if (static_cast<double>(this->At(i, j)) == max)
                {
                    m.ptr->data[i][j]= 1;
                }
                else if (static_cast<double>(this->At(i, j)) == min)
                {
                    m.ptr->data[i][j]=0;
                }
                else
                {
                    m.ptr->data[i][j] = (static_cast<double>(this->At(i, j)) - min) / max;
                }
            }
        }
        return m;
    }

    Mat<T,T1>& operator=(const Mat<T,T1>& m)  //重载赋值运算符，完成对象间的拷贝；
    {
        ptr->height = m.ptr->height;
        ptr->width = m.ptr->width;
        ptr->data = new T* [ptr->height];
        for (int i = 0; i < ptr->height; i++)
        {
            ptr->data[i] = new T[ptr->width];
            for (int j = 0; j < ptr->width; j++)
            {
                ptr->data[i][j] = m.ptr->data[i][j];
            }
        }
        return(*this);
    }
    bool operator==(const Mat<T,T1>& m)  //判断两个Mat对象是否相等
    {
        int flag = 0;
        if (ptr->height != m.ptr->height)
        {
            flag++; cout << "不相等！" << endl;
            return false;
        }
        else if (ptr->width != m.ptr->width)
        {
            flag++; cout << "不相等！" << endl;
            return false;
        }
        else
        {
            for (int i = 0; i < ptr->height; i++)
            {
                for (int j = 0; j < ptr->width; j++)
                {
                    if (ptr->data[i][j] != m.ptr->data[i][j])
                    {
                        cout << "不相等！" << endl;
                        return false;
                    }
                }
            }
        }
        if (flag == 0)
        {
            cout << "相等！" << endl;
            return true;
        }
    }
    friend Mat<T,T1> operator+(const Mat<T,T1>& m1, const Mat<T,T1>& m2) //对应元素的数值相加；
    {
        Mat m(m1);
        for (int i = 0; i < m1.ptr->height; i++)
        {
            for (int j = 0; j < m1.ptr->width; j++)
            {
                m.ptr->data[i][j] = m1.ptr->data[i][j] + m2.ptr->data[i][j];
                if (m.ptr->data[i][j] >= 255)
                {
                    m.ptr->data[i][j] = 255;
                }
            }
        }
        cout << "文件相加成功！" << endl;
        return m;
    }
    friend Mat<T,T1> operator-(const Mat<T,T1>& m1, const Mat<T,T1>& m2)  //对应元素的数值相减；
    {
        Mat m(m1);
        for (int i = 0; i < m1.ptr->height; i++)
        {
            for (int j = 0; j < m1.ptr->width; j++)
            {
                if (m1.ptr->data[i][j] - m2.ptr->data[i][j] <= 0)
                {
                    m.ptr->data[i][j] = 0;
                }
                else
                {
                    m.ptr->data[i][j] = fabs(m1.ptr->data[i][j] - m2.ptr->data[i][j]);
                }
            }
        }
        cout << "文件相减成功！" << endl;
        return m;
    }
    Mat<T,T1>& operator++()  //前置自加；
    {
        for (int i = 0; i < ptr->height; i++)
        {
            for (int j = 0; j < ptr->width; j++)
            {
                ptr->data[i][j]++;
            }
        }
        return *this;
    }
    Mat<T,T1>& operator--() //前置自减；
    {
        for (int i = 0; i < ptr->height; i++)
        {
            for (int j = 0; j < ptr->width; j++)
            {
                ptr->data[i][j]--;
            }
        }
        return *this;
    }
    Mat<T,T1> operator ++(int)  //后置自加；
    {
        Mat old = *this;
        ++(*this);
        return old;
    }
    Mat<T,T1> operator --(int)  //后置自减；
    {
        Mat old = *this;
        --(*this);
        return old;
    }
    Mat<double,T1> operator-() // 取反；注意要把矩阵的数据规整到[0,1]区间后，再用1减
    {
     Normalize();
        for (int i = 0; i < ptr->height; i++)
        {
            for (int j = 0; j < ptr->width; j++)
            {
                ptr->data[i][j] = 1.0 - ptr->data[i][j];
            }
        }
        return (*this);
    }

    friend Mat<T,T1> operator+(Mat<T,T1>& m, T num) //所有元素加上同一数值;
    {
        for (int i = 0; i < m.ptr->height; i++)
        {
            for (int j = 0; j < m.ptr->width; j++)
            {
                m.ptr->data[i][j] += num;
            }
        }
        return m;
    }
    friend Mat<T,T1> operator-(Mat<T,T1>& m, T num) //所有元素减去同一数值;
    {
        for (int i = 0; i < m.ptr->height; i++)
        {
            for (int j = 0; j < m.ptr->width; j++)
            {
                m.ptr->data[i][j] -= num;
            }
        }
        return m;
    }
    friend Mat<T,T1> operator*(Mat<T,T1>& m, T num) //所有元素乘上同一数值;
    {
        for (int i = 0; i < m.ptr->height; i++)
        {
            for (int j = 0; j < m.ptr->width; j++)
            {
                m.ptr->data[i][j] *= num;
            }
        }
        return m;
    }
        friend Mat<T,T1> operator/(Mat<T,T1>&m1, T num)//所有元素除以同一数值;
        {
            Mat m;
            for (int i = 0; i < m1.ptr->height; i++)
            {
                for (int j = 0; j < m1.ptr->width; j++)
                {
                    m.ptr->data[i][j] = m1.ptr->data[i][j] / num;
                }
            }
            return m;
        }
        //另外，用友元函数再写出一个T类型的数和一个Mat对象的加,减,乘,除

        Mat<T,T1> gray2bw(T t)//以给定阈值t进行二值化，返回结果对象
        {
            Normalize();
            for (int i = 0; i < ptr->height; i++)
            {
                for (int j = 0; j < ptr->width; j++)
                {
                    if (ptr->data[i][j] < t)
                    {
                        ptr->data[i][j] = 0;
                    }
                    else
                    {
                        ptr->data[i][j] = 1;
                    }
                }
            }
            cout << "文件二值化成功！" << endl;
            return (*this);
        }

        friend void Swap(Mat<T,T1>&a, Mat<T,T1>&b)//使用友元函数交换两个Mat对象
        {
            int h;
            h = a.ptr->height;
            a.ptr->height = b.ptr->height;
            b.ptr->height = h;
            h = a.ptr->width;
            a.ptr->width = b.ptr->width;
            b.ptr->width = h;
            double** t = a.ptr->data;
            a.ptr->data = b.ptr->data;
            b.ptr->data = t;
        }

    //protected:
        struct Databack// 自己实现一个结构体，来存储矩阵的行数、列数、引用计数和数据指针
        {
            T** data;
            int height;
            int width;
            int refcnt;
        };
        Databack* ptr; // 这里需要声明指向该结构体的指针作为数据成员
    };
 #endif

Filter.hpp

#ifndef FILTER_FPP
#define FILTER_HPP

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<cstdio>
#include"Mat.hpp"
template <class T,class T1>
class Filter
{
public:
    Filter() {}
	Filter(T size) //构造函数
	{
		filtersize = size;
	}
	virtual ~Filter() {} //析构函数;
	virtual Mat<T,T1> Filtering(const Mat<T,T1>& input) = 0; //滤波函数（纯虚函数）;
protected:
	T filtersize;
};


//meanFilter类
template <class T,class T1>
class MeanFilter : public Filter<T,T1>
{
public:
	MeanFilter(T size)
	{
		this->filtersize = size;
	}
	virtual ~MeanFilter(){}
    virtual Mat<T,T1> Filtering(const Mat<T,T1>& input) //均值滤波函数
    {
        int h = input.ptr->height + this->filtersize;
        int w = input.ptr->width + this->filtersize;
        T** m = new T* [h];//扩容
        for (int i = 0; i < h; i++)
        {
            m[i] = new T[w];
            for (int j = 0; j < w; j++)
            {
                m[i][j] = 0;
            }
        }
        for (int i = this->filtersize / 2; i < h - 3; i++)//填充扩容后的m数组,先填充和ptr->data同区域的数据
        {
            for (int j = 0; j < w; j++)
            {
                if (j >= this->filtersize / 2 && j < w - this->filtersize)
                {
                    m[i][j] = input.ptr->data[i - this->filtersize / 2][j - this->filtersize / 2];
                }
                else if (j < this->filtersize / 2)//取右值
                {
                    m[i][j] = input.ptr->data[i - this->filtersize / 2][j];
                }
                else if (j >= w - this->filtersize)//取左值
                {
                    m[i][j] = m[i][j - this->filtersize / 2];
                }
            }
        }
        for (int i = 0; i < h; i++)//填充扩容后的m数组
        {
            for (int j = 0; j < w; j++)
            {
                if (i < this->filtersize / 2)
                {
                    if (j <= w / 2)
                    {
                        m[i][j] = m[i + this->filtersize - 1][j + this->filtersize - 1];//取其右下角的值
                    }
                    else
                    {
                        m[i][j] = m[i + this->filtersize - 1][j - this->filtersize + 1];//取其左下角的值
                    }
                }
                else if (i > input.ptr->height + this->filtersize / 2)
                {
                    if (j <= w / 2)
                    {
                        m[i][j] = m[i - this->filtersize + 1][j + this->filtersize - 1];//取其右上角的值
                    }
                    else
                    {
                        m[i][j] = m[i - this->filtersize + 1][j - this->filtersize + 1];//取其左上角的值
                    }
                }
            }
        }
        for (int i = this->filtersize / 2; i < input.ptr->height + this->filtersize / 2; i++)
        {
            for (int j = this->filtersize / 2; j < input.ptr->width + this->filtersize / 2; j++)
            {
                T sum = 0;
                for (int x = i - this->filtersize / 2; x < i + this->filtersize / 2; x++)
                {
                    for (int y = j - this->filtersize / 2; y < j + this->filtersize / 2; y++)
                    {
                        sum += m[x][y];
                    }
                }
                input.ptr->data[i - this->filtersize / 2][j - this->filtersize / 2] = sum / (T)(this->filtersize * this->filtersize);
            }
        }
        for (int i = 0; i < h; i++)
        {
            delete[]m[i];
        }
        delete[]m;
        return input;
    }
};

template <class T>
T sort(T s[], int len)//选择排序法后返回中间值
{
    int i = 0, j = 0;
    for (int i = 0; i < len - 1; i++)
    {
        int min = i;
        for (int j = i + 1; j < len; j++)
        {
            if (s[j] < s[min])
            {
                min = j;
            }
        }
        T t = s[min];
        s[min] = s[i];
        s[i] = t;
    }
    return s[len / 2];
}

//median类
template <class T,class T1>
class MedianFilter : public Filter<T,T1>
{
public:
	MedianFilter(T size)
	{
		this->filtersize = size;
	}
	virtual ~MedianFilter(){}
	virtual Mat<T,T1> Filtering(const Mat<T,T1>& input) // 中值滤波器函数
	{
        int h = input.ptr->height + this->filtersize;
        int w = input.ptr->width + this->filtersize;
        T** m = new T* [h];//扩容
        for (int i = 0; i < h; i++)
        {
            m[i] = new T[w];
            for (int j = 0; j < w; j++)
            {
                m[i][j] = 0;
            }
        }
        for (int i = this->filtersize / 2; i < h - 3; i++)//填充扩容后的m数组,先填充和ptr->data同区域的数据
        {
            for (int j = 0; j < w; j++)
            {
                if (j >= this->filtersize / 2 && j < w - this->filtersize)
                {
                    m[i][j] = input.ptr->data[i - this->filtersize / 2][j - this->filtersize / 2];
                }
                else if (j < this->filtersize / 2)//取右值
                {
                    m[i][j] = input.ptr->data[i - this->filtersize / 2][j];
                }
                else if (j >= w - this->filtersize)//取左值
                {
                    m[i][j] = m[i][j - this->filtersize / 2];
                }
            }
        }
        for (int i = 0; i < h; i++)//填充扩容后的m数组
        {
            for (int j = 0; j < w; j++)
            {
                if (i < this->filtersize / 2)
                {
                    if (j <= w / 2)
                    {
                        m[i][j] = m[i + this->filtersize - 1][j + this->filtersize - 1];//取其右下角的值
                    }
                    else
                    {
                        m[i][j] = m[i + this->filtersize - 1][j - this->filtersize + 1];//取其左下角的值
                    }
                }
                else if (i > input.ptr->height + this->filtersize / 2)
                {
                    if (j <= w / 2)
                    {
                        m[i][j] = m[i - this->filtersize + 1][j + this->filtersize - 1];//取其右上角的值
                    }
                    else
                    {
                        m[i][j] = m[i - this->filtersize + 1][j - this->filtersize + 1];//取其左上角的值
                    }
                }
            }
        }
        for (int i = this->filtersize / 2; i < input.ptr->height + this->filtersize / 2; i++)
        {
            for (int j = this->filtersize / 2; j < input.ptr->width + this->filtersize / 2; j++)
            {
                int k = 0;
                int sum = this->filtersize * this->filtersize;
                T* s = new T[sum];//将二维数组暂赋给一维数组，调用选择排序求中值
                for (int x = i - this->filtersize / 2; x <= i + this->filtersize / 2; x++)
                {
                    for (int y = j - this->filtersize / 2; y <= j + this->filtersize / 2; y++)
                    {
                        s[k] = m[x][y];
                        k++;
                    }
                }
                input.ptr->data[i - this->filtersize / 2][j - this->filtersize / 2] = sort(s, sum);
            }
        }
        for (int i = 0; i < h; i++)
        {
            delete[]m[i];
        }
        delete[]m;
        return input;
	}
};
#endif
```cpp

四、总结

总结来说，这篇文章是基于之前的实验通过类模板来实现，我认为难点在于结构体中refcnt的使用，它是用于记录指向这块数据的类的个数，防止析构时出现悬垂指针(数据块被析构了，但仍有指针傻傻地继续指向它)等问题。其他就是类里模板函数的书写了，还有就是注意如果模板里定义了两个类型的话，比如T1、T2，在实例化的时候两者都要写清楚。有问题欢迎大家提出一起学习鸭！

whiteeeet
关注
实验8 模板（P292）
Lijing_666的博客
05-31 1757
实验目的和要求1.能够使用C++模板机制定义重载函数。2.能够实例化及使用模板函数。3.能够实例化和使用模板类。4.应用标准C++模板库（STL）通用算法和函数对象实现查找和排序。实验内容1.分析并调试下列程序，了解函数模板的使用。...
计算机课ppt实验报告,ppt模板,实验报告
weixin_28717683的博客
07-08 1768
《ppt模板,实验报告》由会员分享，可在线阅读，更多相关《ppt模板,实验报告(17页珍藏版)》请在人人文库网上搜索。1、ppt模板,实验报告篇一：PPT实验报告模板计算机实验报告课程名称：大学计算机基础实验名称：学院：专业：报告人：级：同组人：指导教师：实验时间：实验报告提交时间：教务处制一、实验目的掌握演示文稿制作的基本过程按时文稿播放的基本操作二、实验内容powerpoint的启动及其窗口1...
面向对象程序设计实验 - 实验9 模板类的构造
qq_41626672的博客
08-10 577
实验九 模板类的构造 目录 实验九 模板类的构造 9.1 实验目的 9.2 实验内容 9.2.1程序阅读 9.2.2 程序设计 9.3思考题 9.1 实验目的 1．理解和应用类模板和函数模板； 2．复习数据结构的相关知识； 3．学习用C++的编程思想实现链表类。 9.2 实验内容 9.2.1程序阅读 1．理解下面的动态数组类模板，它由一系列位置连续、任意数量相同类型的元素组成，其元素个数可在程序运行时改变，并完成该类中没有完成的成员函数（不允许改变已有代码），并设计主函数，实现对
实验九 模板与库使用
weixin_34218890的博客
10-22 117
一、模板的使用 1、新建网页 2、创建模板 创建可编辑区域 3、应用模板 （1）新建网页（应用模板） （2）已有网页应用模板 4、模板修改 超链接修改 可编辑区域变为锁定区域 5、对上次网页布局部分div+css模板就行模板应用，建立系统的网站 二、库的使用 1、新建库文件 2、文件中添加表格等页面信息 3、网页中应用库...
Matlab学习笔记
gsmaster8的博客
11-06 331
Matlab学习笔记（图像处理） 1.size(image)： size(a)表示a数组各个维度的长度，如果a为一幅512×512的灰度图像image： 则 size(image) = [512, 512] 如果image为RGB彩色图像，在matlab中 image = imread('lena.jpg'); // lena.jpg为RGB图像 x = size(image); 可以看到 x ...
燕山大学-面向对象程序设计实验-实验九 模板类的构造-实验报告
QianZe013的博客
03-24 785
燕山大学c++实验报告噢,点个关注嘛
第八章 模板实验
qq_41798482的博客
06-24 496
一 实验目的1、能够使用C++模板机制定义重载函数。2、够实例化及使用模板函数。3、能够实例化和使用模板类。4、应用标准C++模板库（STL）通用算法和函数对象实现查找与排序。二 实验内容1.分析并调试下列程序，了解函数模板的使用。#include&lt;iostream&gt;  using namespace std;  template &lt;class T&gt;  T max(T a,...
汇编语言实验九
lv_jia_wang的博客
06-20 1843
根据材料编程 一、 实验目的 学会按位设置属性字节，从而配置出不同的前景色和背景色。 二、实验内容或主要代码 编程：在屏幕中分别显示绿色、绿底红色、白底蓝色的字符串‘welcome to masm!’。 三、 实验结果或截图 assume cs:code,ds:data,ss:stack data segment db ‘welcome to masm!’ db 02h,24h,71h data ends stack segment dw 8 dup (0) stack ends code segment
电子科技大学实验报告模板
07-13
九、实验数据及结果分析：记录实验中的数据，进行计算和分析，展示实验结果，对比预期结果，分析误差来源。 十、实验结论：基于实验数据和分析，得出结论，验证实验目的是否达成，讨论实验结果的意义。 十一、总结...
软件实验报告模板面向对象程序设计数学.doc
12-18
软件实验报告模板面向对象程序设计数学 本实验报告的主要内容是关于面向对象程序设计的实验报告，旨在掌握类的定义和使用方法、对象的初始化和赋值的方法、成员函数的特性、友元、静态成员的使用方法、this 指针的...
实验九 邮件协议SMTP、POP3与IMAP模板.pdf
06-30
本实验主要探讨了三种关键的邮件协议：SMTP（Simple Mail Transfer Protocol）、POP3（Post Office Protocol version 3）和IMAP（Internet Message Access Protocol）。以下是关于这三种协议的详细解释和它们在实际...
实验模板.rar
10-16
9. **实验九**：实验九可能涵盖移动应用开发，如Android或iOS平台的编程，或者是云计算服务的使用，如AWS或Azure。 10. **实验十**：最后的实验往往是对前面所学知识的综合应用，可能是一个完整的项目开发，如开发...
程序设计基础实验报告模板2020级（实验五）模板.doc
06-24
课后习题部分，学生需要完成第九章的部分例题，这些例题可能涉及到结构体的进一步应用，如日期计算的优化、结构体数组的排序等。例如，提供的部分代码中，有对日期天数计算的改进，考虑了闰年的特殊情况，这是对...
【OpenCV】 Python 图像处理 入门
m0_74183164的博客
09-29 721
【代码】【OpenCV】 Python 图像处理 入门。
传统图像处理Opencv分割不同颜色的夹子
最新发布
向往有那么一天梦幻的步态识别落地，开花❀！
10-06 239
1. 计算图像中夹子的总数。2. 分别计算不同颜色夹子的个数。3. 使用以下方法适应三张图片，并在每张图像上显示结果：- 阈值方法- HSV颜色空间- 连通域分析- 形态学图像处理- Canny边缘检测4. 在结果中显示计数后的数字，包括总数和每种颜色的个数。请学生根据任务要求，编写代码实现夹子计数和颜色分类的功能。学生可以选择使用 Python 和 OpenCV 库来完成任务。他们需要适应三张提供的图像，并在每张图像上显示计数结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值