AccidentalNoise.Mapping.Map3D C# (CSharp) Метод

Map3D() публичный статический Метод

public static Map3D ( MappingMode mappingMode, Double array, ImplicitModuleBase module, MappingRanges ranges ) : void
mappingMode MappingMode
array Double
module ImplicitModuleBase
ranges MappingRanges
Результат void
        public static void Map3D(MappingMode mappingMode, Double[,,] array, ImplicitModuleBase module, MappingRanges ranges)
        {
            var width = array.GetLength(0);
            var height = array.GetLength(1);
            var depth = array.GetLength(2);

            for (var x = 0; x < width; ++x)
            {
                for (var y = 0; y < height; ++y)
                {
                    for (var z = 0; z < depth; ++z)
                    {
                        var p = x / (double)width;
                        var q = y / (double)height;
                        var r = z / (double)depth;
                        double nx;
                        double ny;
                        double nz;
                        double nw;
                        double nu;
                        double dx;
                        double dy;
                        double dz;
                        var val = 0.0;

                        switch (mappingMode)
                        {
                            case MappingMode.SeamlessNone:
                                dx = ranges.MapX1 - ranges.MapX0;
                                dy = ranges.MapY1 - ranges.MapY0;
                                dz = ranges.MapZ1 - ranges.MapZ0;
                                nx = ranges.MapX0 + p*dx;
                                ny = ranges.MapY0 + q*dy;
                                nz = ranges.MapZ0 + r*dz;
                                val = module.Get(nx, ny, nz);
                                break;
                            case MappingMode.SeamlessX:
                                dx = ranges.LoopX1 - ranges.LoopX0;
                                dy = ranges.MapY1 - ranges.MapY0;
                                dz = ranges.MapZ1 - ranges.MapZ0;
                                p = p*(ranges.MapX1 - ranges.MapX0)/(ranges.LoopX1 - ranges.LoopX0);
                                nx = ranges.LoopX0 + Math.Cos(p*PI2)*dx/PI2;
                                ny = ranges.LoopX0 + Math.Sin(p*PI2)*dx/PI2;
                                nz = ranges.MapY0 + q*dy;
                                nw = ranges.MapZ0 + depth*dz;
                                val = module.Get(nx, ny, nz, nw);
                                break;
                            case MappingMode.SeamlessY:
                                dx = ranges.MapX1 - ranges.MapX0;
                                dy = ranges.LoopY1 - ranges.LoopY0;
                                dz = ranges.MapZ1 - ranges.MapZ0;
                                q = q*(ranges.MapY1 - ranges.MapY0)/(ranges.LoopY1 - ranges.LoopY0);
                                nx = ranges.MapX0 + p*dx;
                                ny = ranges.LoopY0 + Math.Cos(q*PI2)*dy/PI2;
                                nz = ranges.LoopY0 + Math.Sin(q*PI2)*dy/PI2;
                                nw = ranges.MapZ0 + r*dz;
                                val = module.Get(nx, ny, nz, nw);
                                break;
                            case MappingMode.SeamlessZ:
                                dx = ranges.MapX1 - ranges.MapX0;
                                dy = ranges.MapY1 - ranges.MapY0;
                                dz = ranges.LoopZ1 - ranges.LoopZ0;
                                r = r*(ranges.MapZ1 - ranges.MapZ0)/(ranges.LoopZ1 - ranges.LoopZ0);
                                nx = ranges.MapX0 + p*dx;
                                ny = ranges.MapY0 + q*dy;
                                nz = ranges.LoopZ0 + Math.Cos(r*PI2)*dz/PI2;
                                nw = ranges.LoopZ0 + Math.Sin(r*PI2)*dz/PI2;
                                val = module.Get(nx, ny, nz, nw);
                                break;
                            case MappingMode.SeamlessXY:
                                dx = ranges.LoopX1 - ranges.LoopX0;
                                dy = ranges.LoopY1 - ranges.LoopY0;
                                dz = ranges.MapZ1 - ranges.MapZ0;
                                p = p*(ranges.MapX1 - ranges.MapX0)/(ranges.LoopX1 - ranges.LoopX0);
                                q = q*(ranges.MapY1 - ranges.MapY0)/(ranges.LoopY1 - ranges.LoopY0);
                                nx = ranges.LoopX0 + Math.Cos(p*PI2)*dx/PI2;
                                ny = ranges.LoopX0 + Math.Sin(p*PI2)*dx/PI2;
                                nz = ranges.LoopY0 + Math.Cos(q*PI2)*dy/PI2;
                                nw = ranges.LoopY0 + Math.Sin(q*PI2)*dy/PI2;
                                nu = ranges.MapZ0 + r*dz;
                                val = module.Get(nx, ny, nz, nw, nu, 0);
                                break;
                            case MappingMode.SeamlessXZ:
                                dx = ranges.LoopX1 - ranges.LoopX0;
                                dy = ranges.MapY1 - ranges.MapY0;
                                dz = ranges.LoopZ1 - ranges.LoopZ0;
                                p = p*(ranges.MapX1 - ranges.MapX0)/(ranges.LoopX1 - ranges.LoopX0);
                                r = r*(ranges.MapZ1 - ranges.MapZ0)/(ranges.LoopZ1 - ranges.LoopZ0);
                                nx = ranges.LoopX0 + Math.Cos(p*PI2)*dx/PI2;
                                ny = ranges.LoopX0 + Math.Sin(p*PI2)*dx/PI2;
                                nz = ranges.MapY0 + q*dy;
                                nw = ranges.LoopZ0 + Math.Cos(r*PI2)*dz/PI2;
                                nu = ranges.LoopZ0 + Math.Sin(r*PI2)*dz/PI2;
                                val = module.Get(nx, ny, nz, nw, nu, 0);
                                break;
                            case MappingMode.SeamlessYZ:
                                dx = ranges.MapX1 - ranges.MapX0;
                                dy = ranges.LoopY1 - ranges.LoopY0;
                                dz = ranges.LoopZ1 - ranges.LoopZ0;
                                q = q*(ranges.MapY1 - ranges.MapY0)/(ranges.LoopY1 - ranges.LoopY0);
                                r = r*(ranges.MapZ1 - ranges.MapZ0)/(ranges.LoopZ1 - ranges.LoopZ0);
                                nx = ranges.MapX0 + p*dx;
                                ny = ranges.LoopY0 + Math.Cos(q*PI2)*dy/PI2;
                                nz = ranges.LoopY0 + Math.Sin(q*PI2)*dy/PI2;
                                nw = ranges.LoopZ0 + Math.Cos(r*PI2)*dz/PI2;
                                nu = ranges.LoopZ0 + Math.Sin(r*PI2)*dz/PI2;
                                val = module.Get(nx, ny, nz, nw, nu, 0);
                                break;
                            case MappingMode.SeamlessXYZ:
                                dx = ranges.LoopX1 - ranges.LoopX0;
                                dy = ranges.LoopY1 - ranges.LoopY0;
                                dz = ranges.LoopZ1 - ranges.LoopZ0;
                                p = p*(ranges.MapX1 - ranges.MapX0)/(ranges.LoopX1 - ranges.LoopX0);
                                q = q*(ranges.MapY1 - ranges.MapY0)/(ranges.LoopY1 - ranges.LoopY0);
                                r = r*(ranges.MapZ1 - ranges.MapZ0)/(ranges.LoopZ1 - ranges.LoopZ0);
                                nx = ranges.LoopX0 + Math.Cos(p*PI2)*dx/PI2;
                                ny = ranges.LoopX0 + Math.Sin(p*PI2)*dx/PI2;
                                nz = ranges.LoopY0 + Math.Cos(q*PI2)*dy/PI2;
                                nw = ranges.LoopY0 + Math.Sin(q*PI2)*dy/PI2;
                                nu = ranges.LoopZ0 + Math.Cos(r*PI2)*dz/PI2;
                                double nv = ranges.LoopZ0 + Math.Sin(r*PI2)*dz/PI2;
                                val = module.Get(nx, ny, nz, nw, nu, nv);
                                break;
                        }
                        array[x, y, z] = val;
                    }
                }
            }
        }
    }