是否可以通过调用matlab中的c/c++代码来加速matlab绘图

您尝试过将渲染方法更改为OpenGL的简单解决方案吗？

opengl hardware;
set(gcf,'Renderer','OpenGL');

警告！在这种模式下，会有一些东西消失，看起来会有点不同，但通常情况下，绘图会运行得更快，特别是如果你有硬件加速器的话。

顺便问一下，你确定你真的会提高性能吗？例如，根据我的经验，C#中的WPF图形比Matlabs慢得多，尤其是散点图和圆。

编辑：我考虑过这样一个事实，即实际绘制到屏幕上的点数不可能那么多。基本上，这意味着你需要在屏幕上有像素的地方进行插值。查看此对象：

classdef InterpolatedPlot < handle
    properties(Access=private)
        hPlot;
    end
    methods(Access=public)
        function this = InterpolatedPlot(x,y,varargin)
            this.hPlot = plot(0,0,varargin{:});
            this.setXY(x,y);
        end        
    end    
    methods
        function setXY(this,x,y)
            parent = get(this.hPlot,'Parent');
            set(parent,'Units','Pixels')
            sz = get(parent,'Position');
            width = sz(3); %Actual width in pixels
            subSampleX = linspace(min(x(:)),max(x(:)),width);
            subSampleY = interp1(x,y,subSampleX);
            set(this.hPlot,'XData',subSampleX,'YData',subSampleY);
        end
    end
end

这里有一个如何使用它的例子：

function TestALotOfPoints()
    x = rand(10000,1);
    y = rand(10000,1);
    ip = InterpolatedPlot(x,y,'color','r','LineWidth',2);
end

另一个可能的改进：此外，如果对x数据进行排序，则可以使用interp1q而不是interp，这样会更快。

classdef InterpolatedPlot < handle
    properties(Access=private)
        hPlot;
    end
%     properties(Access=public)
%         XData;
%         YData;      
%     end
    methods(Access=public)
        function this = InterpolatedPlot(x,y,varargin)
            this.hPlot = plot(0,0,varargin{:});
            this.setXY(x,y);
%             this.XData = x;
%             this.YData = y;
        end        
    end    
    methods
        function setXY(this,x,y)
            parent = get(this.hPlot,'Parent');
            set(parent,'Units','Pixels')
            sz = get(parent,'Position');
            width = sz(3); %Actual width in pixels
            subSampleX = linspace(min(x(:)),max(x(:)),width);
            subSampleY = interp1q(x,y,transpose(subSampleX));
            set(this.hPlot,'XData',subSampleX,'YData',subSampleY);
        end
    end
end

用例：

function TestALotOfPoints()
    x = rand(10000,1);
    y = rand(10000,1);
    x = sort(x);
    ip = InterpolatedPlot(x,y,'color','r','LineWidth',2);
end

由于您希望获得最大性能，因此应考虑编写最小的OpenGL查看器。将所有点转储到一个文件中，并使用MATLAB中的"system"-命令启动查看器。观众可以非常简单。这是一个使用GLUT实现的代码，它是为Mac OS X编译的。该代码是跨平台的，因此您应该能够为您提到的所有平台编译它。根据您的需要调整此查看器应该很容易。

如果你能够将这个查看器与MATLAB更紧密地集成在一起，你就可以不用对文件进行写入和读取（=更新速度更快）。然而，我对这件事没有经验。也许你可以把这个代码放在mex文件中？

编辑：我更新了代码，从CPU内存指针上画了一条条形线。

// On Mac OS X, compile using: g++ -O3 -framework GLUT -framework OpenGL glview.cpp
// The file "input" is assumed to contain a line for each point:
// 0.1 1.0
// 5.2 3.0
#include <vector>
#include <sstream>
#include <fstream>
#include <iostream>
#include <GLUT/glut.h>
using namespace std;
struct float2 { float2() {} float2(float x, float y) : x(x), y(y) {} float x, y; };
static vector<float2> points;
static float2 minPoint, maxPoint;
typedef vector<float2>::iterator point_iter;
static void render() {
    glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(minPoint.x, maxPoint.x, minPoint.y, maxPoint.y, -1.0f, 1.0f);
    glColor3f(0.0f, 0.0f, 0.0f);
    glEnableClientState(GL_VERTEX_ARRAY);
    glVertexPointer(2, GL_FLOAT, sizeof(points[0]), &points[0].x);
    glDrawArrays(GL_LINE_STRIP, 0, points.size());
    glDisableClientState(GL_VERTEX_ARRAY);
    glutSwapBuffers();
}
int main(int argc, char* argv[]) {
    ifstream file("input");
    string line;
    while (getline(file, line)) {
        istringstream ss(line);
        float2 p;
        ss >> p.x;
        ss >> p.y;
        if (ss)
            points.push_back(p);
    }
    if (!points.size())
        return 1;
    minPoint = maxPoint = points[0];
    for (point_iter i = points.begin(); i != points.end(); ++i) {
        float2 p = *i;
        minPoint = float2(minPoint.x < p.x ? minPoint.x : p.x, minPoint.y < p.y ? minPoint.y : p.y);
        maxPoint = float2(maxPoint.x > p.x ? maxPoint.x : p.x, maxPoint.y > p.y ? maxPoint.y : p.y);
    }
    float dx = maxPoint.x - minPoint.x;
    float dy = maxPoint.y - minPoint.y;
    maxPoint.x += dx*0.1f; minPoint.x -= dx*0.1f;
    maxPoint.y += dy*0.1f; minPoint.y -= dy*0.1f;
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
    glutInitWindowSize(512, 512);
    glutCreateWindow("glview");
    glutDisplayFunc(render);
    glutMainLoop();
    return 0;
}

编辑：以下是基于以下讨论的新代码。它呈现了一个由20个vbo组成的sin函数，每个vbo包含100k个点。每个渲染帧会添加10k个新点。这总共得到了2M个点。性能在我的笔记本电脑上是实时的。

// On Mac OS X, compile using: g++ -O3 -framework GLUT -framework OpenGL glview.cpp
#include <vector>
#include <sstream>
#include <fstream>
#include <iostream>
#include <cmath>
#include <iostream>
#include <GLUT/glut.h>
using namespace std;
struct float2 { float2() {} float2(float x, float y) : x(x), y(y) {} float x, y; };
struct Vbo {
    GLuint i;
    Vbo(int size) { glGenBuffersARB(1, &i); glBindBufferARB(GL_ARRAY_BUFFER, i); glBufferDataARB(GL_ARRAY_BUFFER, size, 0, GL_DYNAMIC_DRAW); } // could try GL_STATIC_DRAW
    void set(const void* data, size_t size, size_t offset) { glBindBufferARB(GL_ARRAY_BUFFER, i); glBufferSubData(GL_ARRAY_BUFFER, offset, size, data); }
    ~Vbo() { glDeleteBuffers(1, &i); }
};
static const int vboCount = 20;
static const int vboSize = 100000;
static const int pointCount = vboCount*vboSize;
static float endTime = 0.0f;
static const float deltaTime = 1e-3f;
static std::vector<Vbo*> vbos;
static int vboStart = 0;
static void addPoints(float2* points, int pointCount) {
    while (pointCount) {
        if (vboStart == vboSize || vbos.empty()) {
            if (vbos.size() >= vboCount+2) { // remove and reuse vbo
                Vbo* first = *vbos.begin();
                vbos.erase(vbos.begin());
                vbos.push_back(first);
            }
            else { // create new vbo
                vbos.push_back(new Vbo(sizeof(float2)*vboSize));
            }
            vboStart = 0;
        }
        int pointsAdded = pointCount;
        if (pointsAdded + vboStart > vboSize)
            pointsAdded = vboSize - vboStart;
        Vbo* vbo = *vbos.rbegin();
        vbo->set(points, pointsAdded*sizeof(float2), vboStart*sizeof(float2));
        pointCount -= pointsAdded;
        points += pointsAdded;
        vboStart += pointsAdded;
    }
}
static void render() {
    // generate and add 10000 points
    const int count = 10000;
    float2 points[count];
    for (int i = 0; i < count; ++i) {
        float2 p(endTime, std::sin(endTime*1e-2f));
        endTime += deltaTime;
        points[i] = p;
    }
    addPoints(points, count);
    // render
    glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(endTime-deltaTime*pointCount, endTime, -1.0f, 1.0f, -1.0f, 1.0f);
    glColor3f(0.0f, 0.0f, 0.0f);
    glEnableClientState(GL_VERTEX_ARRAY);
    for (size_t i = 0; i < vbos.size(); ++i) {
        glBindBufferARB(GL_ARRAY_BUFFER, vbos[i]->i);
        glVertexPointer(2, GL_FLOAT, sizeof(float2), 0);
        if (i == vbos.size()-1)
            glDrawArrays(GL_LINE_STRIP, 0, vboStart);
        else
            glDrawArrays(GL_LINE_STRIP, 0, vboSize);
    }
    glDisableClientState(GL_VERTEX_ARRAY);
    glutSwapBuffers();
    glutPostRedisplay();
}
int main(int argc, char* argv[]) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
    glutInitWindowSize(512, 512);
    glutCreateWindow("glview");
    glutDisplayFunc(render);
    glutMainLoop();
    return 0;
}

正如许多人在回答中提到的那样，您不需要绘制那么多点。我认为听取安德烈的评论很重要：

这是一个巨大的分数！屏幕上没有足够的像素来绘制这个数量。

用不同的语言重写绘图例程是在浪费时间。编写MATLAB已经花了很多小时，是什么让你认为你可以（在合理的时间内）编写一个明显更快的绘图程序？虽然你的例程可能不那么通用，因此会删除MATLAB代码将执行的一些检查，但你的"瓶颈"是你试图绘制这么多数据。

我强烈推荐两种行动方案之一：

• 采样您的数据：您不需要在一个图形上有20 x 1000000个点-人眼无法区分所有点，因此这是浪费时间。例如，尝试对数据进行装箱。

• 如果你坚持认为你需要屏幕上的所有这些点，我建议你使用不同的工具。VisIt或ParaView是我脑海中浮现的两个例子。它们是并行可视化程序，旨在处理超大数据集（我见过VisIt处理包含PetaBytes数据的数据集）。

没有办法在一个小图上拟合1000000个数据点。你从每10000个点中选择一个，然后把它们画出来怎么样？

您可以考虑对大向量调用imresize来收缩它，但通过省略99%的点来手动构建向量可能会更快。

@memyself采样操作已经在进行。Matlab正在选择要包含在图中的数据。你为什么信任matlab？在我看来，你展示的图表严重歪曲了数据。密集区域应该表明信号处于恒定值，但在您的图中，这可能意味着信号在一半的时间内处于该值，或者在对应于该像素的间隔内至少处于该值一次？

是否可以使用替代架构？例如，使用MATLAB生成数据，并使用快速库或应用程序（GNUplot？）处理绘图？

甚至可以让MATLAB在绘图仪消耗数据时将数据写入流。然后，当MATLAB生成数据时，该图将被更新。

这种方法可以避免MATLAB绘制速度慢得离谱，并将工作分为两个单独的过程。OS/CPU可能会理所当然地将进程分配给不同的内核。

我认为这是可能的，但可能需要从头开始编写绘图代码（至少是您使用的部分），因为任何可以重用的东西都会让您放慢速度。

为了测试可行性，我首先测试任何Win32 GUI是否能从MEX工作（调用MessageBox），然后继续创建自己的窗口，测试窗口消息是否到达WndProc。一旦完成了这一切，您就可以将OpenGL上下文绑定到它（或者只使用GDI），并开始绘图。

然而，节省的成本可能来自于更简单的绘图代码和使用较新的OpenGL功能（如VBO），而不是线程。GPU上的一切都已经是并行的，更多的线程无助于更快地将命令/数据传输到GPU。

多年前（2004？）我也做过类似的事情。我需要一个类似示波器的显示器，用于实时显示千赫采样的生物信号。虽然没有最初的问题那么多，但对于MATLAB来说仍然太多了，无法单独处理。IIRC我最终编写了一个Java组件来显示图形。

正如其他人所建议的那样，我最终也对数据进行了抽样。对于x轴上的每个像素，我计算出数据的最小值和最大值，然后在这些值之间画一条短的垂直线。整个图形由一系列短的垂直线组成，每条垂直线紧挨着一条。

事实上，我认为该实现最终将图形写入了使用bitblt连续滚动的位图，只绘制了新的点。。。或者位图是静态的，视口沿着它滚动。。。不管怎么说，那是很久以前的事了，我可能记不清了。

区块报价第四版：我知道这是一个很大的情节点，但我从来没有说过这个问题很容易。我不能只忽略某些数据点，因为在实际绘制之前，无法评估哪些点是重要的区块报价

这是不正确的。有一种方法可以知道应该忽略哪些点。Matlab已经在做了。无论你如何解决这个问题，在某个时刻都必须要做一些事情。我认为你需要把你的问题改为"我如何确定我应该画出哪些点？"。

根据屏幕截图，数据看起来像一个波形。你可能想看看大胆的代码。这是一个开源的音频编辑程序。它显示实时表示波形的图形，它们的样式与最低屏幕截图中的样式相同。你可以从他们那里借用一些采样技术。

您想要的是创建一个MEX文件。

与其由我来解释，您可能会从阅读以下内容中受益更多：创建可从MATLAB调用的C/C++和Fortran程序（MEX文件）（MathWorks的一篇文档文章）。

希望这能有所帮助。