Refine search
/** * @param doublePointer * @param length * @return */ @Override public DataBuffer create(DoublePointer doublePointer, long length) { doublePointer.capacity(length); doublePointer.limit(length); doublePointer.position(0); return new DoubleBuffer(doublePointer, DoubleIndexer.create(doublePointer), length); }
/** Returns {@code this} where {@code array/buffer[i * strides[0] + j] = d[offset:offset + length]} */ public abstract DoubleIndexer put(long i, long j, double[] d, int offset, int length); /** Returns {@code this} where {@code array/buffer[i * strides[0] + j * strides[1] + k] = d} */
/** Returns {@code this} where {@code d[offset:offset + length] = array/buffer[i]} */ public abstract DoubleIndexer get(long i, double[] d, int offset, int length); /** Returns {@code array/buffer[i * strides[0] + j]} */
/** * Create a data buffer from * the given length * * @param buffer * @param length */ public BaseDataBuffer(ByteBuffer buffer, long length) { if (length < 1) throw new IllegalArgumentException("Length must be >= 1"); initTypeAndSize(); this.length = length; allocationMode = AllocUtil.getAllocationModeFromContext(); if (dataType() == Type.DOUBLE) { pointer = new DoublePointer(buffer.asDoubleBuffer()); setIndexer(DoubleIndexer.create((DoublePointer) pointer)); } else if (dataType() == Type.FLOAT) { pointer = new FloatPointer(buffer.asFloatBuffer()); setIndexer(FloatIndexer.create((FloatPointer) pointer)); } else if (dataType() == Type.INT) { pointer = new IntPointer(buffer.asIntBuffer()); setIndexer(IntIndexer.create((IntPointer) pointer)); } else if (dataType() == Type.LONG) { pointer = new LongPointer(buffer.asLongBuffer()); setIndexer(LongIndexer.create((LongPointer) pointer)); } // log.info("Creating new buffer of size: {}; dtype: {}; D", length, dataType()); }
: (I)ShortIndexer.create(new ShortPointer((ShortBuffer)buffer), sizes, strides, false).indexable(this); case DEPTH_INT: return array != null ? (I)IntIndexer.create((int[])array, sizes, strides).indexable(this) : direct ? (I)IntIndexer.create((IntBuffer)buffer, sizes, strides).indexable(this) : (I)IntIndexer.create(new IntPointer((IntBuffer)buffer), sizes, strides, false).indexable(this); case DEPTH_LONG: : (I)LongIndexer.create(new LongPointer((LongBuffer)buffer), sizes, strides, false).indexable(this); case DEPTH_FLOAT: return array != null ? (I)FloatIndexer.create((float[])array, sizes, strides).indexable(this) : direct ? (I)FloatIndexer.create((FloatBuffer)buffer, sizes, strides).indexable(this) : (I)FloatIndexer.create(new FloatPointer((FloatBuffer)buffer), sizes, strides, false).indexable(this); case DEPTH_DOUBLE: return array != null ? (I)DoubleIndexer.create((double[])array, sizes, strides).indexable(this) : direct ? (I)DoubleIndexer.create((DoubleBuffer)buffer, sizes, strides).indexable(this) : (I)DoubleIndexer.create(new DoublePointer((DoubleBuffer)buffer), sizes, strides, false).indexable(this); default: assert false;
indexer = IntIndexer.create((IntPointer) pointer); if (t == Type.INT) Iindexer.put(i, s.readInt()); else if (t == Type.DOUBLE) Iindexer.put(i, (int) s.readDouble()); else if (t == Type.FLOAT) Iindexer.put(i, (int) s.readFloat()); indexer = DoubleIndexer.create((DoublePointer) pointer); Dindexer.put(i, s.readDouble()); else if (t == Type.FLOAT) Dindexer.put(i, (double) s.readFloat()); else if (t == Type.HALF) Dindexer.put(i, (double) toFloat((int) s.readShort())); indexer = FloatIndexer.create((FloatPointer) pointer); Findexer.put(i, (float) s.readDouble()); else if (t == Type.FLOAT) Findexer.put(i, s.readFloat()); else if (t == Type.HALF) { Findexer.put(i, toFloat((int) s.readShort()));
FloatIndexer retidx = FloatIndexer.create((FloatPointer) pagedPointer.asFloatPointer(), new long[] {channels, rows, cols}, new long[] {stride[0], stride[1], stride[2]}); if (idx instanceof UByteIndexer) { for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { retidx.put(k, i, j, ubyteidx.get(i, j, k)); DoubleIndexer retidx = DoubleIndexer.create((DoublePointer) pagedPointer.asDoublePointer(), new long[] {channels, rows, cols}, new long[] {stride[0], stride[1], stride[2]}); if (idx instanceof UByteIndexer) { for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { retidx.put(k, i, j, ubyteidx.get(i, j, k)); for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { retidx.put(k, i, j, ushortidx.get(i, j, k)); for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { retidx.put(k, i, j, intidx.get(i, j, k)); for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { retidx.put(k, i, j, floatidx.get(i, j, k));
@Override public void put(long i, int element) { if (dataType() == Type.DOUBLE) { ((DoubleIndexer) indexer).put(offset() + i, element); } else if (dataType() == Type.INT) { ((IntIndexer) indexer).put(offset() + i, element); } else if (dataType() == Type.LONG) { ((LongRawIndexer) indexer).put(offset() + i, element); } else { ((FloatIndexer) indexer).put(offset() + i, element); } if (i == length) { length++; } }
/** * * @param data * @param copy */ public BaseDataBuffer(double[] data, boolean copy) { allocationMode = AllocUtil.getAllocationModeFromContext(); initTypeAndSize(); pointer = new DoublePointer(data); indexer = DoubleIndexer.create((DoublePointer) pointer); //wrappedBuffer = pointer.asByteBuffer(); length = data.length; underlyingLength = data.length; }
@Override public DoubleIndexer createIndexer(boolean direct) { int[] w = {0}, h = {0}; dpixGetDimensions((DPIX)this, w, h); int wpl = dpixGetWpl((DPIX)this); long[] sizes = {h[0], w[0], wpl / w[0]}; long[] strides = {wpl, wpl / w[0], 1}; DoublePointer data = new DoublePointer(dpixGetData((DPIX)this)).capacity(h[0] * wpl); return DoubleIndexer.create(data, sizes, strides, direct); }
@Override public double getDouble(long i) { if (indexer == null) { throw new IllegalStateException("Indexer must never be null"); } if (dataType() == Type.FLOAT) { return ((FloatIndexer) indexer).get(offset() + i); } else if (dataType() == Type.INT) { return ((IntIndexer) indexer).get(offset() + i); } else if (dataType() == Type.LONG) { return ((LongRawIndexer) indexer).get(offset() + i); } else { return ((DoubleIndexer) indexer).get(offset() + i); } }
hMultiplierIndexer.put(0, 0, hMultiplierIndexer.get(0, 0) / hMultiplierIndexer.get(2, 2)); //0 hMultiplierIndexer.put(0, 1, hMultiplierIndexer.get(0, 1) / hMultiplierIndexer.get(2, 2)); //1 hMultiplierIndexer.put(0, 2, hMultiplierIndexer.get(0, 2) / hMultiplierIndexer.get(2, 2)); //2 hMultiplierIndexer.put(1, 0, hMultiplierIndexer.get(1, 0) / hMultiplierIndexer.get(2, 2)); //3 hMultiplierIndexer.put(1, 1, hMultiplierIndexer.get(1, 1) / hMultiplierIndexer.get(2, 2)); //4 hMultiplierIndexer.put(1, 2, hMultiplierIndexer.get(1, 2) / hMultiplierIndexer.get(2, 2)); //5 hMultiplierIndexer.put(2, 0, hMultiplierIndexer.get(2, 0) / hMultiplierIndexer.get(2, 2)); //6 hMultiplierIndexer.put(2, 1, hMultiplierIndexer.get(2, 1) / hMultiplierIndexer.get(2, 2)); //7 hMultiplierIndexer.put(2, 2, hMultiplierIndexer.get(2, 2) / hMultiplierIndexer.get(2, 2)); //8 trajectoryCIndexer.put(0, i - 1, hMultiplierIndexer.get(0, 0)); //0 trajectoryCIndexer.put(1, i - 1, hMultiplierIndexer.get(0, 1)); //1 trajectoryCIndexer.put(2, i - 1, hMultiplierIndexer.get(0, 2)); //2 trajectoryCIndexer.put(3, i - 1, hMultiplierIndexer.get(1, 0)); //3 trajectoryCIndexer.put(4, i - 1, hMultiplierIndexer.get(1, 1)); //4 trajectoryCIndexer.put(5, i - 1, hMultiplierIndexer.get(1, 2)); //5 trajectoryCIndexer.put(6, i - 1, hMultiplierIndexer.get(2, 0)); //6 trajectoryCIndexer.put(7, i - 1, hMultiplierIndexer.get(2, 1)); //7 trajectoryCIndexer.put(8, i - 1, hMultiplierIndexer.get(2, 2)); //8 hSmoothedIndexer.put(0, 0, trajectorySmoothCIndexer.get(0, p - 1)); //0 hSmoothedIndexer.put(0, 1, trajectorySmoothCIndexer.get(1, p - 1)); //1 hSmoothedIndexer.put(0, 2, trajectorySmoothCIndexer.get(2, p - 1)); //2 hSmoothedIndexer.put(1, 0, trajectorySmoothCIndexer.get(3, p - 1)); //3 hSmoothedIndexer.put(1, 1, trajectorySmoothCIndexer.get(4, p - 1)); //4 hSmoothedIndexer.put(1, 2, trajectorySmoothCIndexer.get(5, p - 1)); //5 hSmoothedIndexer.put(2, 0, trajectorySmoothCIndexer.get(6, p - 1)); //6 hSmoothedIndexer.put(2, 1, trajectorySmoothCIndexer.get(7, p - 1)); //7 hSmoothedIndexer.put(2, 2, trajectorySmoothCIndexer.get(8, p - 1)); //8
public BaseDataBuffer(double[] data, boolean copy, MemoryWorkspace workspace) { allocationMode = AllocUtil.getAllocationModeFromContext(); length = data.length; underlyingLength = data.length; attached = true; parentWorkspace = workspace; initTypeAndSize(); //log.info("Allocating FloatPointer from array of {} elements", data.length); pointer = workspace.alloc(data.length * getElementSize(), dataType(), false).asDoublePointer().put(data); workspaceGenerationId = workspace.getGenerationId(); indexer = DoubleIndexer.create((DoublePointer) pointer); //wrappedBuffer = pointer.asByteBuffer(); }
/** Returns {@code create(pointer, sizes, strides, true)} */ public static DoubleIndexer create(DoublePointer pointer, long[] sizes, long[] strides) { return create(pointer, sizes, strides, true); } /**
/** * * @param length * @param elementSize */ public BaseDataBuffer(long length, int elementSize) { if (length < 1) throw new IllegalArgumentException("Length must be >= 1"); initTypeAndSize(); allocationMode = AllocUtil.getAllocationModeFromContext(); this.length = length; this.underlyingLength = length; this.elementSize = (byte) elementSize; if (dataType() == Type.DOUBLE) { pointer = new DoublePointer(length); indexer = DoubleIndexer.create((DoublePointer) pointer); } else if (dataType() == Type.FLOAT) { pointer = new FloatPointer(length); setIndexer(FloatIndexer.create((FloatPointer) pointer)); } else if (dataType() == Type.INT) { pointer = new IntPointer(length); setIndexer(IntIndexer.create((IntPointer) pointer)); } else if (dataType() == Type.LONG) { pointer = new LongPointer(length); setIndexer(LongIndexer.create((LongPointer) pointer)); } // log.info("Creating new buffer of size: {}; dtype: {}; C", length, dataType()); }
public BaseCudaDataBuffer(@NonNull DataBuffer underlyingBuffer, long length, long offset) { //this(length, underlyingBuffer.getElementSize(), offset); this.allocationMode = AllocationMode.LONG_SHAPE; initTypeAndSize(); this.wrappedDataBuffer = underlyingBuffer; this.originalBuffer = underlyingBuffer.originalDataBuffer() == null ? underlyingBuffer : underlyingBuffer.originalDataBuffer(); this.length = length; this.offset = offset; this.originalOffset = offset; this.trackingPoint = underlyingBuffer.getTrackingPoint(); this.elementSize = (byte) underlyingBuffer.getElementSize(); this.allocationPoint = ((BaseCudaDataBuffer) underlyingBuffer).allocationPoint; if (underlyingBuffer.dataType() == Type.DOUBLE) { this.pointer = new CudaPointer(allocationPoint.getPointers().getHostPointer(), originalBuffer.length()).asDoublePointer(); indexer = DoubleIndexer.create((DoublePointer) pointer); } else if (underlyingBuffer.dataType() == Type.FLOAT) { this.pointer = new CudaPointer(allocationPoint.getPointers().getHostPointer(), originalBuffer.length()).asFloatPointer(); indexer = FloatIndexer.create((FloatPointer) pointer); } else if (underlyingBuffer.dataType() == Type.INT) { this.pointer = new CudaPointer(allocationPoint.getPointers().getHostPointer(), originalBuffer.length()).asIntPointer(); indexer = IntIndexer.create((IntPointer) pointer); } else if (underlyingBuffer.dataType() == Type.HALF) { this.pointer = new CudaPointer(allocationPoint.getPointers().getHostPointer(), originalBuffer.length()).asShortPointer(); indexer = HalfIndexer.create((ShortPointer) pointer); } else if (underlyingBuffer.dataType() == Type.LONG) { this.pointer = new CudaPointer(allocationPoint.getPointers().getHostPointer(), originalBuffer.length()).asLongPointer(); indexer = LongIndexer.create((LongPointer) pointer); } }
: (I)ShortIndexer.create(new ShortPointer((ShortBuffer)buffer), sizes, strides, false).indexable(this); case DEPTH_INT: return array != null ? (I)IntIndexer.create((int[])array, sizes, strides).indexable(this) : direct ? (I)IntIndexer.create((IntBuffer)buffer, sizes, strides).indexable(this) : (I)IntIndexer.create(new IntPointer((IntBuffer)buffer), sizes, strides, false).indexable(this); case DEPTH_LONG: : (I)LongIndexer.create(new LongPointer((LongBuffer)buffer), sizes, strides, false).indexable(this); case DEPTH_FLOAT: return array != null ? (I)FloatIndexer.create((float[])array, sizes, strides).indexable(this) : direct ? (I)FloatIndexer.create((FloatBuffer)buffer, sizes, strides).indexable(this) : (I)FloatIndexer.create(new FloatPointer((FloatBuffer)buffer), sizes, strides, false).indexable(this); case DEPTH_DOUBLE: return array != null ? (I)DoubleIndexer.create((double[])array, sizes, strides).indexable(this) : direct ? (I)DoubleIndexer.create((DoubleBuffer)buffer, sizes, strides).indexable(this) : (I)DoubleIndexer.create(new DoublePointer((DoubleBuffer)buffer), sizes, strides, false).indexable(this); default: assert false;
indexer = IntIndexer.create((IntPointer) pointer); Iindexer.put(i, s.readInt()); else if (t == Type.LONG) Iindexer.put(i, (int) s.readLong()); else if (t == Type.DOUBLE) Iindexer.put(i, (int) s.readDouble()); indexer = DoubleIndexer.create((DoublePointer) pointer); Dindexer.put(i, s.readDouble()); else if (t == Type.LONG) Dindexer.put(i, (double) s.readLong()); else if (t == Type.FLOAT) Dindexer.put(i, (double) s.readFloat()); else if (t == Type.HALF) Dindexer.put(i, (double) toFloat((int) s.readShort())); indexer = FloatIndexer.create((FloatPointer) pointer); Findexer.put(i, (float) s.readDouble()); else if (t == Type.LONG) Findexer.put(i, (float) s.readLong()); else if (t == Type.FLOAT) Findexer.put(i, s.readFloat());