用C++语言或者C语言实现图像识别和图像处理功能是从拍摄的BMP或者JPG格式的图像文件中识别出被拍摄物体的轮廓和外接矩形并根据外接矩形识别出物体的横纵两条中轴线不能使用opencv库或者ImageMagick等第三方库

实现图像识别和处理的过程大致可以分为以下几个步骤：

读取图像文件，获取图像的宽度和高度以及像素信息；
对图像进行二值化处理，将图像转换为黑白图像；
对二值化后的图像进行轮廓检测，找到物体的轮廓；
根据轮廓计算出物体的外接矩形；
根据外接矩形计算出物体的中轴线。

下面给出一份基于C++语言的图像识别和处理代码示例，具体实现方法如下：

#include <iostream>
#include <fstream>
#include <vector>
#include <cmath>

using namespace std;

// 定义像素类型，用于存储图像像素信息
typedef struct {
    unsigned char b;
    unsigned char g;
    unsigned char r;
} Pixel;

// 定义矩形类型，用于存储物体的外接矩形
typedef struct {
    int left;
    int top;
    int right;
    int bottom;
} Rect;

// 定义点类型，用于存储轮廓上的点
typedef struct {
    int x;
    int y;
} Point;

// 计算两个点之间的距离
double distance(Point p1, Point p2)
{
    return sqrt(pow(p1.x - p2.x, 2) + pow(p1.y - p2.y, 2));
}

// 将图像转换为黑白图像
void binaryImage(Pixel* image, int width, int height)
{
    const int threshold = 128; // 阈值
    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            int index = y * width + x;
            unsigned char gray = (image[index].r + image[index].g + image[index].b) / 3;
            if (gray > threshold) {
                image[index].r = image[index].g = image[index].b = 255;
            } else {
                image[index].r = image[index].g = image[index].b = 0;
            }
        }
    }
}

// 检测轮廓
void findContours(Pixel* image, int width, int height, vector<Point>& contours)
{
    const int kernel_size = 3;
    const int threshold = 128;
    const int dx[] = { 1, 0, -1, 0 };
    const int dy[] = { 0, 1, 0, -1 };
    vector<unsigned char> visited(width * height, 0);
    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            int index = y * width + x;
            if (!visited[index] && image[index].r < threshold) {
                Point start = { x, y };
                vector<Point> contour;
                contour.push_back(start);
                visited[index] = 1;
                int cur_x = x, cur_y = y;
                int dir = 3;
                while (1) {
                    int next_dir = (dir + 1) % 4;
                    int next_x = cur_x + dx[next_dir];
                    int next_y = cur_y + dy[next_dir];
                    int next_index = next_y * width + next_x;
                    if (next_x >= 0 && next_x < width && next_y >= 0 && next_y < height && !visited[next_index] && image[next_index].r < threshold) {
                        contour.push_back({ next_x, next_y });
                        visited[next_index] = 1;
                        cur_x = next_x;
                        cur_y = next_y;
                        dir = next_dir;
                    } else {
                        dir = (dir + 3) % 4;
                    }
                    if (cur_x == x && cur_y == y && dir == 3) {
                        break;
                    }
                }
                contours.insert(contours.end(), contour.begin(), contour.end());
            }
        }
    }
}

// 计算外接矩形
void boundingRect(const vector<Point>& contours, Rect& rect)
{
    rect.left = rect.top = 0x7fffffff;
    rect.right = rect.bottom = 0x80000000;
    for (int i = 0; i < contours.size(); i++) {
        rect.left = min(rect.left, contours[i].x);
        rect.top = min(rect.top, contours[i].y);
        rect.right = max(rect.right, contours[i].x);
        rect.bottom = max(rect.bottom, contours[i].y);
    }
}

// 计算中轴线
void axis(const Rect& rect, Point& horizontal_axis, Point& vertical_axis)
{
    horizontal_axis.x = (rect.left + rect.right) / 2;
    horizontal_axis.y = rect.top;
    vertical_axis.x = rect.left;
    vertical_axis.y = (rect.top + rect.bottom) / 2;
}

int main(int argc, char** argv)
{
    if (argc < 2) {
        cout << "Usage: " << argv[0] << " [image_file]" << endl;
        return -1;
    }

    // 读取图像文件
    ifstream fin(argv[1], ios::binary);
    if (!fin) {
        cout << "Failed to open file: " << argv[1] << endl;
        return -1;
    }
    char header[54];
    fin.read(header, 54);
    int width = *(int*)(header + 18);
    int height = *(int*)(header + 22);
    int row_bytes = (width * 24 + 31) / 32 * 4;
    int padding_bytes = row_bytes - width * 3;
    Pixel* image = new Pixel[width * height];
    for (int y = height - 1; y >= 0; y--) {
        for (int x = 0; x < width; x++) {
            int index = y * width + x;
            fin.read((char*)(image + index), 3);
        }
        fin.seekg(padding_bytes, ios::cur);
    }
    fin.close();

    // 转换为黑白图像
    binaryImage(image, width, height);

    // 检测轮廓
    vector<Point> contours;
    findContours(image, width, height, contours);

    // 计算外接矩形
    Rect rect;
    boundingRect(contours, rect);

    // 计算中轴线
    Point horizontal_axis, vertical_axis;
    axis(rect, horizontal_axis, vertical_axis);

    // 输出结果
    cout << "Bounding Box: (" << rect.left << ", " << rect.top << "), (" << rect.right << ", " << rect.bottom << ")" << endl;
    cout << "Horizontal Axis: (" << horizontal_axis.x << ", " << horizontal_axis.y << ")" << endl;
    cout << "Vertical Axis: (" << vertical_axis.x << ", " << vertical_axis.y << ")" << endl;

    delete[] image;

    return 0;
}

该代码示例可以读取BMP格式的图像文件，将图像转换为黑白图像，并检测出轮廓，计算出物体的外接矩形和中轴线，并输出结果