/** Constructor to set the {@link #pointer}, {@link #sizes} and {@link #strides}. */ public FloatRawIndexer(FloatPointer pointer, long[] sizes, long[] strides) { super(sizes, strides); this.pointer = pointer; base = pointer.address() + pointer.position() * VALUE_BYTES; size = pointer.limit() - pointer.position(); }
/** Calls {@code FloatRawIndexer(pointer, { pointer.limit() - pointer.position() }, { 1 })}. */ public FloatRawIndexer(FloatPointer pointer) { this(pointer, new long[] { pointer.limit() - pointer.position() }, ONE_STRIDE); }
@Override public void release() { pointer.position(position).put(array); super.release(); } };
/** Returns {@code create(pointer, { pointer.limit() - pointer.position() }, { 1 }, true)} */ public static FloatIndexer create(FloatPointer pointer) { return create(pointer, new long[] { pointer.limit() - pointer.position() }, ONE_STRIDE); }
/** * @param floatPointer * @param length * @return */ @Override public DataBuffer create(FloatPointer floatPointer, long length) { floatPointer.capacity(length); floatPointer.limit(length); floatPointer.position(0); return new FloatBuffer(floatPointer, FloatIndexer.create(floatPointer), length); }
/** * Creates a float indexer to access efficiently the data of a pointer. * * @param pointer data to access via a buffer or to copy to an array * @param direct {@code true} to use a direct buffer, see {@link Indexer} for details * @return the new float indexer backed by the raw memory interface, a buffer, or an array */ public static FloatIndexer create(final FloatPointer pointer, long[] sizes, long[] strides, boolean direct) { if (direct) { return Raw.getInstance() != null ? new FloatRawIndexer(pointer, sizes, strides) : new FloatBufferIndexer(pointer.asBuffer(), sizes, strides); } else { final long position = pointer.position(); float[] array = new float[(int)Math.min(pointer.limit() - position, Integer.MAX_VALUE)]; pointer.get(array); return new FloatArrayIndexer(array, sizes, strides) { @Override public void release() { pointer.position(position).put(array); super.release(); } }; } }
/** * For direct buffers, calls {@link Pointer#Pointer(Buffer)}, while for buffers * backed with an array, allocates enough memory for the array and copies it. * * @param buffer the Buffer to reference or copy * @see #put(float[]) */ public FloatPointer(FloatBuffer buffer) { super(buffer); if (buffer != null && !buffer.isDirect() && buffer.hasArray()) { float[] array = buffer.array(); allocateArray(array.length - buffer.arrayOffset()); put(array, buffer.arrayOffset(), array.length - buffer.arrayOffset()); position(buffer.position()); limit(buffer.limit()); } } /**
/** * Returns the native FloatPointer of this array, pointing to the position 0. * @return pointer to this array. */ /*package visible*/ @FloatPrecisionVersion FloatPointer getPointer() { return pointer.position(0); }
/** * Returns the value at specified index. * <pre> * {@code return nativeArray[i]; } * </pre> * @param i index * @return value at i */ @FloatPrecisionVersion public float get(long i){ if(i >= this.length){ throw new ArrayIndexOutOfBoundsException( String.format("Cannot get value at %d, array is of length %d", i, this.length)); } return pointer.position(0).get(i); }
/** * Sets specified value at specified index. * <pre> * {@code nativeArray[i] = v; } * </pre> * @param i index * @param v value * @return this for chaining */ @FloatPrecisionVersion public NativeRealArray set(long i, float v){ if(i >= this.length){ throw new ArrayIndexOutOfBoundsException( String.format("Cannot set value at %d, array is of length %d", i, this.length)); } pointer.position(0).put(i, v); return this; }
/** * Reads <i>length</i> number of elements from the specified * array starting at <i>offset</i> and puts them into this * native array starting at <i>i</i>. * <pre> * {@code for(j=0;j<length;j++) nativeArray[i+j]=values[offset+j]; } * </pre> * @param i offset into this native array * @param length number of values to be copied * @param offset into the specified array * @param values the array from which values will be copied * @return this for chaining * * @throws IllegalArgumentException when specified offset plus length exceeds the specified values array's length */ @FloatPrecisionVersion public NativeRealArray set(long i, int length, int offset, float[] values){ if(offset+length > values.length){ throw new IllegalArgumentException( String.format("Cannot read %d values starting from %d, argument array is only of length %d", length, offset, values.length)); } if(i+length > this.length){ throw new ArrayIndexOutOfBoundsException( String.format("Number of values to be set (%d) to insert at index %d exceed length of this array (%d)", length, i, this.length)); } pointer.position(i).put(values, offset, length); return this; }
length, i, this.length)); pointer.position(i).get(destination,offset,length); return destination;
/** @return {@link FPIX#data()} wrapped in a {@link FloatBuffer} starting at given byte index. */ public FloatBuffer createBuffer(int index) { int[] w = {0}, h = {0}; fpixGetDimensions((FPIX)this, w, h); int wpl = fpixGetWpl((FPIX)this); FloatPointer data = new FloatPointer(fpixGetData((FPIX)this)).position(index).capacity(h[0] * wpl); return data.asBuffer(); }
private MatVector wrapInputLayer() { Mat[] inputChannels = new Mat[numChannels]; FloatPointer inputData = net.input_blobs().get(0).mutable_cpu_data(); for (int i = 0; i < numChannels; i++) { inputData.position(i * width * height * inputData.sizeof()); inputChannels[i] = new Mat(height, width, CV_32FC1, inputData); } return new MatVector(inputChannels); }
private static Mat meanImage(String meanFile, FloatNet net) { BlobProto blobProto = new BlobProto(); ReadProtoFromBinaryFileOrDie(meanFile, blobProto); FloatBlob meanBlob = new FloatBlob(); meanBlob.FromProto(blobProto); int numChannels = meanBlob.channels(); FloatBlob inputLayer = net.input_blobs().get(0); if (numChannels != inputLayer.channels()) { throw new IllegalStateException("Number of channels of mean file doesn't match input layer"); } Mat[] channels = new Mat[numChannels]; FloatPointer data = meanBlob.mutable_cpu_data(); int meanHeight = meanBlob.height(); int meanWidth = meanBlob.width(); for (int i = 0; i < numChannels; i++) { data.position(i * meanHeight * meanWidth * data.sizeof()); channels[i] = new Mat(meanHeight, meanWidth, CV_32FC1, data); } Mat mean = new Mat(); merge(new MatVector(channels), mean); Scalar channelMean = mean(mean); return new Mat(inputLayer.height(), inputLayer.width(), mean.type(), channelMean); }
FloatBuffer b = (FloatBuffer)samples[i]; if (samples_in[i] instanceof FloatPointer && samples_in[i].capacity() >= inputSize && b.hasArray()) { ((FloatPointer)samples_in[i]).position(0).put(b.array(), b.position(), inputSize); } else { samples_in[i] = new FloatPointer(b);
FloatBuffer b = (FloatBuffer)samples[i]; if (samples_in[i] instanceof FloatPointer && samples_in[i].capacity() >= inputSize && b.hasArray()) { ((FloatPointer)samples_in[i]).position(0).put(b.array(), b.position(), inputSize); } else { samples_in[i] = new FloatPointer(b);
/** Returns {@link #tensor_data()} wrapped in a {@link Buffer} of appropriate type starting at given index. */ public <B extends Buffer> B createBuffer(long index) { BytePointer ptr = tensor_data(); long size = TotalBytes(); switch (dtype()) { case DT_COMPLEX64: case DT_FLOAT: return (B)new FloatPointer(ptr).position(index).capacity(size/4).asBuffer(); case DT_DOUBLE: return (B)new DoublePointer(ptr).position(index).capacity(size/8).asBuffer(); case DT_QINT32: case DT_INT32: return (B)new IntPointer(ptr).position(index).capacity(size/4).asBuffer(); case DT_BOOL: case DT_QUINT8: case DT_UINT8: case DT_QINT8: case DT_INT8: return (B)ptr.position(index).capacity(size).asBuffer(); case DT_BFLOAT16: case DT_INT16: return (B)new ShortPointer(ptr).position(index).capacity(size/2).asBuffer(); case DT_INT64: return (B)new LongPointer(ptr).position(index).capacity(size/8).asBuffer(); case DT_STRING: default: assert false; } return null; }