|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
| Packages that use FlatField | |
|---|---|
| visad | The core VisAD package, providing support for VisAD's Data & MathType hierarchy, as well as for VisAD Displays and remote collaboration. |
| visad.bom | |
| visad.data | Provides for importing data to and exporting data from VisAD. |
| visad.data.amanda | |
| visad.data.dods | Supports read-only access to datasets on DODS servers by importing such datasets as VisAD data objects. |
| visad.data.fits | Provides for importing a FITS dataset into VisAD. |
| visad.data.gif | Provides for importing GIF, JPEG and PNG files into VisAD. |
| visad.data.hdfeos | Provides for importing an HDF-EOS dataset into VisAD. |
| visad.data.hrit | |
| visad.data.mcidas | Provides for importing McIDAS AREA files and McIDAS base map (OUTL) files into VisAD. |
| visad.data.netcdf.in | Provides for importing a netCDF dataset into VisAD. |
| visad.data.tiff | |
| visad.data.vis5d | Provides for importing a Vis5D dataset into VisAD. |
| visad.data.visad | Provides for importing and exporting serialized Java object files into and out of VisAD. |
| visad.data.visad.object | |
| visad.jmet | |
| visad.math | |
| visad.matrix | |
| visad.meteorology | Provides classes that are useful in the field of meteorology. |
| visad.python | |
| visad.sounder | |
| visad.util | Provides a collection of useful utilities, many of them GUI widgets, to aid in VisAD application design. |
| Uses of FlatField in visad |
|---|
| Subclasses of FlatField in visad | |
|---|---|
class |
ImageFlatField
ImageFlatField is a VisAD FlatField backed by a java.awt.image.BufferedImage object, instead of the usual float[][] or double[][] samples array. |
| Methods in visad that return FlatField | |
|---|---|
protected FlatField |
FlatField.cloneDouble(MathType f_type,
Unit[] units,
ErrorEstimate[] errors)
|
protected FlatField |
FlatField.cloneDouble(MathType f_type,
Unit[] units,
ErrorEstimate[] errors,
double[][] newValues)
|
protected FlatField |
FlatField.cloneFloat(MathType f_type,
Unit[] units,
ErrorEstimate[] errors)
|
protected FlatField |
FlatField.cloneFloat(MathType f_type,
Unit[] units,
ErrorEstimate[] errors,
float[][] newValues)
|
static FlatField |
FlatField.makeField(FunctionType type,
int length,
boolean irregular)
construct a FlatField of given type; used for testing |
static FlatField |
FlatField.makeField1(FunctionType type,
double first1,
double last1,
int length1,
double first2,
double last2,
int length2)
construct a FlatField with a 2-D domain and a 1-D range; used for testing |
static FlatField |
FlatField.makeField2(FunctionType type,
double first1,
double last1,
int length1,
double first2,
double last2,
int length2)
construct a FlatField with a 2-D domain and a 2-D range; used for testing |
| Methods in visad with parameters of type FlatField | |
|---|---|
static void |
FlatField.fillField(FlatField image,
double step,
double half)
|
| Constructors in visad with parameters of type FlatField | |
|---|---|
RemoteFlatFieldImpl(FlatField flatField)
construct a RemoteFieldImpl object to provide remote access to field |
|
| Uses of FlatField in visad.bom |
|---|
| Methods in visad.bom that return FlatField | |
|---|---|
FlatField |
RadarAdapter.getData()
|
static FlatField |
TCData.makeLocations(double[] times,
float[] lats,
float[] lons,
float[] errors,
int[] confidence,
int[] location_styles,
float[] wind_means,
float[] wind_gusts,
float[] central_pressures,
int[] categories,
int[] intensityStyle,
float[] gale_radii,
float[] storm_radii,
float[] hurricane_radii,
float[] radii_of_maximum_winds,
int[] size_styles,
float[] depth,
float[] eyeDiameter,
float[] pressureOfLastClosedIsobar,
int[] structureStyle)
jk: create a flatfield of Disturbance (Tropical Cyclone) Sizes with values set to "missing" This allows for the case when the database has no entries yet, but means we can still create some TCData |
static FlatField |
GridEdit.warpGrid(FlatField ff,
float[][][] set_samples,
float[][] deltas)
warpGrid is the workhorse of GridEdit and can be used independently of any instances of the class |
| Methods in visad.bom with parameters of type FlatField | |
|---|---|
void |
CollectiveBarbManipulation.addStation(FlatField station)
|
static Tuple |
TCData.makeTrack(String track_type,
String track_name,
double base_date_time,
double create_date_time,
String display_type,
FlatField locations)
|
static FlatField |
GridEdit.warpGrid(FlatField ff,
float[][][] set_samples,
float[][] deltas)
warpGrid is the workhorse of GridEdit and can be used independently of any instances of the class |
| Uses of FlatField in visad.data |
|---|
| Subclasses of FlatField in visad.data | |
|---|---|
class |
AreaImageCacheAdapter
Adapts a FlatField backed by a AreaImageAccessor to work
with a FlatFieldCache. |
class |
CachedFlatField
This is a FloatField that caches to disk its float array. |
class |
FileFlatField
|
| Methods in visad.data that return FlatField | |
|---|---|
abstract FlatField |
FileAccessor.getFlatField()
|
| Methods in visad.data with parameters of type FlatField | |
|---|---|
int |
CacheStrategy.allocate(FlatField[] adaptedFlatFields,
boolean[] adaptedFlatFieldDirty,
long[] adaptedFlatFieldSizes,
long[] adaptedFlatFieldTimes)
|
void |
EmptyDataProcessor.processFlatField(FunctionType type,
Set domainSet,
CoordinateSystem cs,
CoordinateSystem[] rangeCS,
Set[] rangeSets,
Unit[] units,
FlatField fld,
Object token)
|
void |
DataProcessor.processFlatField(FunctionType type,
Set domainSet,
CoordinateSystem cs,
CoordinateSystem[] rangeCS,
Set[] rangeSets,
Unit[] units,
FlatField fld,
Object token)
|
abstract void |
BaseDataProcessor.processFlatField(FunctionType type,
Set domainSet,
CoordinateSystem cs,
CoordinateSystem[] rangeCS,
Set[] rangeSets,
Unit[] units,
FlatField fld,
Object token)
|
abstract double[][] |
FileAccessor.readFlatField(FlatField template,
int[] fileLocation)
|
boolean |
DataVisitor.visit(FlatField field)
Visit a VisAD FlatField. |
abstract void |
FileAccessor.writeFlatField(double[][] values,
FlatField template,
int[] fileLocation)
|
| Uses of FlatField in visad.data.amanda |
|---|
| Methods in visad.data.amanda that return FlatField | |
|---|---|
FlatField |
AmandaFile.makeModuleData()
|
| Uses of FlatField in visad.data.dods |
|---|
| Methods in visad.data.dods that return FlatField | |
|---|---|
FlatField |
VectorAccessor.getFlatField()
Returns a VisAD FlatField corresponding to this instance. |
FlatField |
SequenceVariableAdapter.SequenceAccessor.getFlatField()
Returns a VisAD FlatField corresponding to this instance. |
FlatField |
GridVariableAdapter.GridAccessor.getFlatField()
Returns a VisAD FlatField corresponding to this instance. |
| Methods in visad.data.dods with parameters of type FlatField | |
|---|---|
double[][] |
VectorAccessor.readFlatField(FlatField template,
int[] fileLocation)
Throws a VisADError. |
double[][] |
SequenceVariableAdapter.SequenceAccessor.readFlatField(FlatField template,
int[] fileLocation)
Throws a VisADError. |
double[][] |
GridVariableAdapter.GridAccessor.readFlatField(FlatField template,
int[] fileLocation)
Throws a VisADError. |
void |
VectorAccessor.writeFlatField(double[][] values,
FlatField template,
int[] fileLocation)
Throws a VisADError. |
void |
SequenceVariableAdapter.SequenceAccessor.writeFlatField(double[][] values,
FlatField template,
int[] fileLocation)
Throws a VisADError. |
void |
GridVariableAdapter.GridAccessor.writeFlatField(double[][] values,
FlatField template,
int[] fileLocation)
Throws a VisADError. |
| Uses of FlatField in visad.data.fits |
|---|
| Constructors in visad.data.fits with parameters of type FlatField | |
|---|---|
ConvertDoubleArray(FlatField fld)
|
|
| Uses of FlatField in visad.data.gif |
|---|
| Methods in visad.data.gif that return FlatField | |
|---|---|
FlatField |
GIFAdapter.getData()
|
| Uses of FlatField in visad.data.hdfeos |
|---|
| Methods in visad.data.hdfeos that return FlatField | |
|---|---|
FlatField |
HdfeosAccessor.getFlatField()
|
| Methods in visad.data.hdfeos with parameters of type FlatField | |
|---|---|
double[][] |
HdfeosAccessor.readFlatField(FlatField template,
int[] fileLocation)
|
void |
HdfeosAccessor.writeFlatField(double[][] values,
FlatField template,
int[] fileLocation)
|
| Uses of FlatField in visad.data.hrit |
|---|
| Methods in visad.data.hrit that return FlatField | |
|---|---|
FlatField |
HRITAdapter.getData()
|
| Uses of FlatField in visad.data.mcidas |
|---|
| Methods in visad.data.mcidas that return FlatField | |
|---|---|
FlatField |
AreaAdapter.getData()
Return a FlatField representing the image. |
| Uses of FlatField in visad.data.netcdf.in |
|---|
| Methods in visad.data.netcdf.in that return FlatField | |
|---|---|
FlatField |
FileDataFactory.netCDFFlatFieldAccessor.getFlatField()
Returns the associated FlatField. |
FlatField |
FileDataFactory.newData(Context context,
VirtualFlatField virtualField)
Creates a VisAD FlatField object from a netCDF indicial context and a VirtualFlatField. |
FlatField |
DataFactory.newData(Context context,
VirtualFlatField virtualField)
Creates a VisAD FlatField object from a netCDF indicial context and a VirtualFlatField. |
| Methods in visad.data.netcdf.in with parameters of type FlatField | |
|---|---|
double[][] |
FileDataFactory.netCDFFlatFieldAccessor.readFlatField(FlatField template,
int[] fileLocation)
Returns null. |
void |
FileDataFactory.netCDFFlatFieldAccessor.writeFlatField(double[][] values,
FlatField template,
int[] fileLocation)
Does nothing. |
| Uses of FlatField in visad.data.tiff |
|---|
| Methods in visad.data.tiff with parameters of type FlatField | |
|---|---|
void |
TiffForm.saveImage(String id,
FlatField image,
Hashtable ifd,
boolean last)
|
| Uses of FlatField in visad.data.vis5d |
|---|
| Methods in visad.data.vis5d that return FlatField | |
|---|---|
FlatField |
Vis5DFileAccessor.getFlatField()
|
FlatField |
Vis5DForm.getFlatField(Vis5DFile v5dfile,
int time_idx)
|
FlatField |
Vis5DAdaptedForm.getFlatField(Vis5DFile file,
int time_idx)
|
static FlatField |
Vis5DForm.makeFlatField(Vis5DFile v5dfile,
int time_idx)
|
| Methods in visad.data.vis5d with parameters of type FlatField | |
|---|---|
double[][] |
Vis5DFileAccessor.readFlatField(FlatField template,
int[] fileLocation)
|
void |
Vis5DFileAccessor.writeFlatField(double[][] values,
FlatField template,
int[] fileLocation)
|
| Uses of FlatField in visad.data.visad |
|---|
| Methods in visad.data.visad with parameters of type FlatField | |
|---|---|
void |
BinaryWriter.processFlatField(FunctionType type,
Set domainSet,
CoordinateSystem cs,
CoordinateSystem[] rangeCS,
Set[] rangeSets,
Unit[] units,
FlatField fld,
Object token)
|
void |
BinarySizer.processFlatField(FunctionType type,
Set domainSet,
CoordinateSystem cs,
CoordinateSystem[] rangeCS,
Set[] rangeSets,
Unit[] units,
FlatField fld,
Object token)
|
| Uses of FlatField in visad.data.visad.object |
|---|
| Methods in visad.data.visad.object that return FlatField | |
|---|---|
static FlatField |
BinaryFlatField.read(BinaryReader reader,
int objLen,
boolean cacheFile)
|
| Methods in visad.data.visad.object with parameters of type FlatField | |
|---|---|
static int |
BinaryFlatField.computeBytes(Set domainSet,
CoordinateSystem cs,
CoordinateSystem[] rangeCS,
Set[] rangeSets,
Unit[] units,
FlatField fld)
|
static void |
BinaryFlatField.write(BinaryWriter writer,
FunctionType type,
Set domainSet,
CoordinateSystem cs,
CoordinateSystem[] rangeCS,
Set[] rangeSets,
Unit[] units,
FlatField fld,
Object token)
|
static void |
BinaryFlatField.writeDependentData(BinaryWriter writer,
FunctionType type,
Set domainSet,
CoordinateSystem cs,
CoordinateSystem[] rangeCS,
Set[] rangeSets,
Unit[] units,
FlatField fld,
Object token)
|
| Uses of FlatField in visad.jmet |
|---|
| Fields in visad.jmet declared as FlatField | |
|---|---|
protected FlatField |
MetGrid.data
|
| Uses of FlatField in visad.math |
|---|
| Methods in visad.math that return FlatField | |
|---|---|
static FlatField |
FFT.backwardFT(Data[] datums)
for use by SpreadSheet only - ordinary applications should use other method signatures; invoke in SpreadSheet by: link(visad.math.FFT.backwardFT(A1)) |
static FlatField |
FFT.forwardFT(Data[] datums)
for use by SpreadSheet only - ordinary applications should use other method signatures; invoke in SpreadSheet by: link(visad.math.FFT.forwardFT(A1)) |
static FlatField |
FFT.fourierTransform(Field field,
boolean forward)
return Fourier Transform of field, use FFT if domain dimension(s) are powers of 2 |
static FlatField |
FFT.fourierTransform(Field field,
boolean forward,
FunctionType ftype,
GriddedSet domain_set,
CoordinateSystem range_coord_sys,
Set[] range_sets,
Unit[] units)
return Fourier Transform of field, use FFT if domain dimension(s) are powers of 2 |
static FlatField |
Histogram.makeHistogram(Data[] datums)
invoke in SpreadSheet by: link(visad.math.Histogram.makeHistogram(A1, A2)) |
static FlatField |
Histogram.makeHistogram(Field field,
Set set)
return a histogram of field range values in "bins" defined by the samples of set |
| Uses of FlatField in visad.matrix |
|---|
| Subclasses of FlatField in visad.matrix | |
|---|---|
class |
JamaMatrix
JamaMatrix is a VisAD wrapper for JAMA matrices. |
| Methods in visad.matrix with parameters of type FlatField | |
|---|---|
static JamaMatrix |
JamaMatrix.convertToMatrix(FlatField field)
Attempt to convert the given VisAD FlatField to a VisAD JamaMatrix Data object. |
| Uses of FlatField in visad.meteorology |
|---|
| Subclasses of FlatField in visad.meteorology | |
|---|---|
class |
NavigatedImage
An implementation for representing single-banded planar satellite or radar imagery. |
class |
SatelliteImage
An implementation for representing single-banded planar satellite that has navigation. |
class |
SingleBandedImageImpl
An implementation for representing single-banded planar satellite or radar imagery. |
| Constructors in visad.meteorology with parameters of type FlatField | |
|---|---|
NavigatedImage(FlatField image,
DateTime startTime,
String desc)
Construct a NavigatedImage from a FlatField. |
|
NavigatedImage(FlatField image,
DateTime startTime,
String desc,
boolean copyData)
Construct a NavigatedImage from a FlatField. |
|
SatelliteImage(FlatField image,
DateTime startTime,
String desc,
String sensor)
Construct a Satellite Image from a FlatField. |
|
SingleBandedImageImpl(FlatField image,
DateTime startTime,
String desc)
Construct a SingleBandedImageImpl from a FlatField. |
|
SingleBandedImageImpl(FlatField image,
DateTime startTime,
String desc,
boolean copyData)
Construct a SingleBandedImage from the FlatField specified. |
|
| Uses of FlatField in visad.python |
|---|
| Methods in visad.python that return FlatField | |
|---|---|
static FlatField |
JPythonMethods.createAreaField(FieldImpl f)
construct a Field containing the computed area of each data point |
static FlatField |
JPythonMethods.fft(Field field)
return forward Fourier transform of field, which should have
either a 1-D or 2-D gridded domain; uses FFT when domain size
is a power of two; returns real and imaginary parts |
static FlatField |
JPythonMethods.field(float[] values)
Return a VisAD FlatField with default 1-D domain and with range values given by values array |
static FlatField |
JPythonMethods.field(float[][] values)
Return a VisAD FlatField with default 2-D domain and with range values given by values array |
static FlatField |
JPythonMethods.field(Set set,
String name,
float[] values)
Return a VisAD FlatField with given 1-D domain set, with range values given by values array, and with given range RealType name |
static FlatField |
JPythonMethods.field(Set set,
String name,
float[][] values)
return a VisAD FlatField with given 2-D domain set, with range values given by values array, and with given range RealType name |
static FlatField |
JPythonMethods.field(String name,
float[] values)
Return a VisAD FlatField with default 1-D domain, with range values given by values array, and with given range RealType name |
static FlatField |
JPythonMethods.field(String name,
float[][] values)
Return a VisAD FlatField with default 2-D domain, with range values given by values array, and with given range RealType name |
static FlatField |
JPythonMethods.field(String dom0,
String name,
float[] values)
Return a VisAD FlatField with default 1-D domain, with range values given by values array, and with given range RealType name |
static FlatField |
JPythonMethods.field(String dom0,
String dom1,
String rng,
float[][] values)
Return a VisAD FlatField with named default 2-D domain, with range values given by values array and with given range RealType name |
static FlatField |
JPythonMethods.hist(Field field,
int[] ranges)
Return histogram of range values of field selected by ranges array, with dimension = ranges.length, and 64 equally spaced bins in each dimension |
static FlatField |
JPythonMethods.hist(Field field,
int[] ranges,
int[] sizes)
Return histogram of range values of field selected by ranges array, with dimension = ranges.length, and with number of equally spaced bins in each dimension determined by sizes array |
static FlatField |
JPythonMethods.hist(Field field,
Set set)
return histogram of range values of field selected by set, with dimension and bin sampling defined by set |
static FlatField |
JPythonMethods.ifft(Field field)
return backward Fourier transform of field, which should have either a 1-D or 2-D gridded domain; uses fft when domain size is a power of two; returns real and imaginary parts |
static FlatField |
JPythonMethods.maskNoNavigation(FieldImpl f)
Return a mask for points with navigation (1) or not (0) |
static FlatField |
JPythonMethods.replace(FieldImpl f,
double v)
Replaces all the values in a FlatField with the constant given |
static FlatField |
JPythonMethods.replace(FieldImpl f,
int[] list,
double v)
Replaces specified values in a FlatField with the constant given |
static FlatField |
JPythonMethods.replace(FieldImpl f,
int[] list,
Real v)
Replaces specified values in a FlatField with the constant given |
static FlatField |
JPythonMethods.replace(FieldImpl f,
Real v)
Replaces all the values in a FlatField with the constant given |
static FlatField |
JPythonMethods.replaceMissing(FieldImpl f,
double v)
Replaces all the missing values in a FlatField with the constant given |
static FlatField |
JPythonMethods.setMissingNoNavigation(FieldImpl f)
For all non-navigatable points in the given FlatField, replace the FF's values with missing (Float.NaN). |
static FlatField |
JPythonMethods.setToMissing(FieldImpl f,
double v)
Replaces all the given values in a FlatField with the missing value (Float.NaN); |
| Methods in visad.python with parameters of type FlatField | |
|---|---|
static JamaCholeskyDecomposition |
JPythonMethods.chol(FlatField data)
return matrix Cholesky Decomposition of data, as a 1-Tuple (lower_triangular_factor); data should have either a 1-D or 2-D gridded domain |
static double |
JPythonMethods.computeAverage(FlatField f,
int[] list)
Compute the average of each point named in the list (see "createArea" method) |
static double |
JPythonMethods.computeSum(FlatField f,
int[] list)
Sum up the values of each point named in the list (see "createAreaField" method) |
static double |
JPythonMethods.cond(FlatField data)
return matrix condition of data (ratio of largest to smallest singular value), which should have either a 1-D or 2-D gridded domain |
static double |
JPythonMethods.det(FlatField data)
return matrix determinant of data, which should have either a 1-D or 2-D gridded domain |
static JamaEigenvalueDecomposition |
JPythonMethods.eig(FlatField data)
return matrix Eigenvalue Decomposition of data, as a 3-Tuple (eigenvector_matrix, real_eigenvalue_components, imaginary_eigenvalue_components); data should have either a 1-D or 2-D gridded domain |
static JamaMatrix |
JPythonMethods.inverse(FlatField data)
return matrix inverse of data, which should have either a 1-D or 2-D gridded domain |
static JamaLUDecomposition |
JPythonMethods.lu(FlatField data)
return matrix LU Decomposition of data, as a 3-Tuple (lower_triangular_factor, upper_triangular_factor, pivot_permutation_vector); data should have either a 1-D or 2-D gridded domain |
static JamaMatrix |
JPythonMethods.matrixMultiply(FlatField data1,
FlatField data2)
return matrix multiply of data1 * data2, which should have either 1-D or 2-D gridded domains |
static double |
JPythonMethods.norm1(FlatField data)
return matrix one norm of data (maximum column sum), which should have either a 1-D or 2-D gridded domain |
static double |
JPythonMethods.norm2(FlatField data)
return matrix two norm of data (maximum singular value), which should have either a 1-D or 2-D gridded domain |
static double |
JPythonMethods.normF(FlatField data)
return matrix Frobenius norm of data (sqrt of sum of squares of all elements), which should have either a 1-D or 2-D gridded domain |
static double |
JPythonMethods.normInf(FlatField data)
return matrix infinity norm of data (maximum row sum), which should have either a 1-D or 2-D gridded domain |
static JamaQRDecomposition |
JPythonMethods.qr(FlatField data)
return matrix QR Decomposition of data, as a 2-Tuple (orthogonal_factor, upper_triangular_factor); data should have either a 1-D or 2-D gridded domain |
static double |
JPythonMethods.rank(FlatField data)
return matrix effective numerical rank (from SVD) of data, which should have either a 1-D or 2-D gridded domain |
static JamaMatrix |
JPythonMethods.solve(FlatField data1,
FlatField data2)
return matrix soluton X of data1 * X = data2; data12 and data2 should have either 1-D or 2-D gridded domains; return solution if data1 is is square, least squares solution otherwise |
static JamaSingularValueDecomposition |
JPythonMethods.svd(FlatField data)
return matrix Singular Value Decomposition of data, as a 3-Tuple (left_singular_vectors, right_singular_vectors, singular_value_vector); data should have either a 1-D or 2-D gridded domain |
static double |
JPythonMethods.trace(FlatField data)
return matrix trace of data (sum of the diagonal elements), which should have either a 1-D or 2-D gridded domain |
static JamaMatrix |
JPythonMethods.transpose(FlatField data)
return matrix transpose of data, which should have either a 1-D or 2-D gridded domain |
| Uses of FlatField in visad.sounder |
|---|
| Subclasses of FlatField in visad.sounder | |
|---|---|
class |
Sounding
Sounding is the VisAD class for atmospheric soundings. |
class |
Spectrum
Sounding is the VisAD class for atmospheric soundings. |
| Uses of FlatField in visad.util |
|---|
| Methods in visad.util that return FlatField | |
|---|---|
static FlatField[] |
DataUtility.getImageFields(Data data)
|
static FlatField |
BarGraph.makeBarGraph2D(float[] heights,
float spacing,
Color[] colors)
Constructs a 2D bar graph. |
static FlatField |
BarGraph.makeBarGraph2D(FunctionType type,
float[] heights,
float spacing,
Color[] colors)
Constructs a 2D bar graph. |
static FlatField |
BarGraph.makeBarGraph3D(float[][] heights,
float spacing,
Color[][] colors)
Constructs a 3D bar graph. |
static FlatField |
BarGraph.makeBarGraph3D(FunctionType type,
float[][] heights,
float spacing,
Color[][] colors)
Constructs a 3D bar graph. |
static FlatField |
BarGraph.makeBoxes2D(float[] x1,
float[] y1,
float[] x2,
float[] y2,
Color[] c)
|
static FlatField |
BarGraph.makeBoxes2D(float[] x1,
float[] y1,
float[] x2,
float[] y2,
float[] r,
float[] g,
float[] b)
|
static FlatField |
BarGraph.makeBoxes2D(FunctionType type,
float[] x1,
float[] y1,
float[] x2,
float[] y2,
Color[] c)
|
static FlatField |
BarGraph.makeBoxes2D(FunctionType type,
float[] x1,
float[] y1,
float[] x2,
float[] y2,
float[] r,
float[] g,
float[] b)
|
static FlatField |
BarGraph.makeBoxes3D(float[] x1,
float[] y1,
float[] z1,
float[] x2,
float[] y2,
float[] z2,
Color[] c)
|
static FlatField |
BarGraph.makeBoxes3D(float[] x1,
float[] y1,
float[] z1,
float[] x2,
float[] y2,
float[] z2,
float[] r,
float[] g,
float[] b)
|
static FlatField |
BarGraph.makeBoxes3D(FunctionType type,
float[] x1,
float[] y1,
float[] z1,
float[] x2,
float[] y2,
float[] z2,
Color[] c)
|
static FlatField |
BarGraph.makeBoxes3D(FunctionType type,
float[] x1,
float[] y1,
float[] z1,
float[] x2,
float[] y2,
float[] z2,
float[] r,
float[] g,
float[] b)
|
static FlatField |
DataUtility.makeField(Image image)
Create a VisAD Data object from the given Image |
static FlatField |
DataUtility.makeField(Image image,
boolean withAlpha)
Create a VisAD Data object from the given Image |
static FlatField |
DataUtility.makeImage(float[][] values)
return a FlatField for a simple image from values[nlines][nelements] |
| Methods in visad.util with parameters of type FlatField | |
|---|---|
static GriddedSet |
DataUtility.createGriddedSet(FlatField field,
boolean copy)
Creates a GriddedSet from a FlatField. |
static Image |
DataUtility.extractImage(FlatField field,
boolean reverse)
Converts a flat field of the form ((x, y) -> (r, g, b)) to an AWT Image. |
static float[][] |
DataUtility.getPixels(FlatField image)
|
static Unit[] |
DataUtility.getRangeUnits(FlatField field)
Gets the units of the (flat) components of the range of a FlatField. |
static void |
DataUtility.setPixels(FlatField image,
float[][] values)
set pixel values in a simple image, indexed as values[line][element] |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
