如何在2D网格上绘制张量可视化

Question

I want to implement (ac# program) the system in this paper IPSM It uses tensor field to design street network. For my implementation, my priority is to generate my own street network from my own tensor field. I don't want something too advanced at first. The paper said that tensor lines (major and minor eigenvector) will represent the streets. Does anyone have any ideas where should I start to look at (how can I draw those lines inside a 2D grid). There are some references inside the paper such tensor field visualization paper but I can't stop turning inside a loop looking one reference to another one.

Regards.

Answer 1

I'm going to assume that it's the drawing part you need help with. C# has a number of drawing capabilities that make it pretty easy to draw stuff like this. GDI+ (the graphics/drawing package contained in System.Drawing) has built-in support for 2D transformations, so we can create a bitmap and then draw on it using arbitrary coordinate systems. You can also leverage the existing Vector class in the System.Windows namespace to make vector math simpler.

First, the namespaces and assemblies you'll need:

using System;

// Needs reference to System.Drawing to use GDI+ for drawing
using System.Drawing; 
using System.Drawing.Imaging;

// Needs reference to WindowBase to use Vector class
using Vector = System.Windows.Vector;

The following example just draws a 10x10 grid of vectors. The output looks like this. The code will run just fine inside of a console application (ie no user interface). You could also modify the code to generate the bitmap and display in a Windows Forms application via a picture box or some other UI element. The console version, though, is dead simple and easy to play around with:

// Define the size of our viewport using arbitary world coordinates
var viewportSize = new SizeF(10, 10);

// Create a new bitmap image that is 500 by 500 pixels
using (var bmp = new Bitmap(500, 500, PixelFormat.Format32bppPArgb))
{
    // Create graphics object to draw on the bitmap
    using (var g = Graphics.FromImage(bmp))
    {
        // Set up transformation so that drawing calls automatically convert world coordinates into bitmap coordinates
        g.TranslateTransform(0, bmp.Height * 0.5f - 1);
        g.ScaleTransform(bmp.Width / viewportSize.Width, -bmp.Height / viewportSize.Height);
        g.TranslateTransform(0, -viewportSize.Height * 0.5f);

        // Create pen object for drawing with
        using (var redPen = new Pen(Color.Red, 0.01f)) // Note that line thickness is in world coordinates!
        {
            // Randomization
            var rand = new Random();

            // Draw a 10x10 grid of vectors
            var a = new Vector();
            for (a.X = 0.5; a.X < 10.0; a.X += 1.0)
            {
                for (a.Y = 0.5; a.Y < 10.0; a.Y += 1.0)
                {
                    // Connect the center of this cell to a random point inside the cell
                    var offset = new Vector(rand.NextDouble() - 0.5, rand.NextDouble() - 0.5);
                    var b = a + offset;
                    g.DrawLine(redPen, a.ToPointF(), b.ToPointF());
                }
            }
        }
    }

    // Save the bitmap and display it
    string filename = System.IO.Path.Combine(
        Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
        "c#test.png");
    bmp.Save(filename, ImageFormat.Png);
    System.Diagnostics.Process.Start(filename);
}

Answer 2

You are going to need to do quite a lot of work to develop a system like they have. You first step will be to draw the flow lines of a vector field. There is a lot of literature on the topic because it is a big area. I would recommend getting a book on the subject rather than trying to work with papers which are always missing on the nitty gritty details.

Once you have a framework which can do streamlines, you can move onto the other parts of the algorithm. To simplify the algorithm I would look at the section on height-maps. If you could generate a height-map over the whole domain then you define one of the vectors as the gradient and draw some stream lines from that vector field.

This might be a good way to get a fairly simple working system. Their full algorithm is really quite involved. I would say you would need about a month of work to implement their whole algorithm.