• Home
• org.bytedeco.javacpp-presets
• caffe
• master-1.1
• source code
• caffe.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.bytedeco.javacpp.caffe Maven / Gradle / Ivy

// Targeted by JavaCPP version 1.1

package org.bytedeco.javacpp;

import java.nio.*;
import org.bytedeco.javacpp.*;
import org.bytedeco.javacpp.annotation.*;

import static org.bytedeco.javacpp.opencv_core.*;
import static org.bytedeco.javacpp.opencv_imgproc.*;
import static org.bytedeco.javacpp.opencv_imgcodecs.*;
import static org.bytedeco.javacpp.opencv_videoio.*;
import static org.bytedeco.javacpp.opencv_highgui.*;

public class caffe extends org.bytedeco.javacpp.presets.caffe {
    static { Loader.load(); }

@Name("std::map::Creator>") public static class FloatRegistry extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public FloatRegistry(Pointer p) { super(p); }
    public FloatRegistry()       { allocate();  }
    private native void allocate();
    public native @Name("operator=") @ByRef FloatRegistry put(@ByRef FloatRegistry x);

    public native long size();

    @Index public native FloatLayerRegistry.Creator get(@StdString BytePointer i);
    public native FloatRegistry put(@StdString BytePointer i, FloatLayerRegistry.Creator value);

    public native @ByVal Iterator begin();
    public native @ByVal Iterator end();
    @NoOffset @Name("iterator") public static class Iterator extends Pointer {
        public Iterator(Pointer p) { super(p); }
        public Iterator() { }

        public native @Name("operator++") @ByRef Iterator increment();
        public native @Name("operator==") boolean equals(@ByRef Iterator it);
        public native @Name("operator*().first") @MemberGetter @StdString BytePointer first();
        public native @Name("operator*().second") @MemberGetter FloatLayerRegistry.Creator second();
    }
}

@Name("std::map::Creator>") public static class DoubleRegistry extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public DoubleRegistry(Pointer p) { super(p); }
    public DoubleRegistry()       { allocate();  }
    private native void allocate();
    public native @Name("operator=") @ByRef DoubleRegistry put(@ByRef DoubleRegistry x);

    public native long size();

    @Index public native DoubleLayerRegistry.Creator get(@StdString BytePointer i);
    public native DoubleRegistry put(@StdString BytePointer i, DoubleLayerRegistry.Creator value);

    public native @ByVal Iterator begin();
    public native @ByVal Iterator end();
    @NoOffset @Name("iterator") public static class Iterator extends Pointer {
        public Iterator(Pointer p) { super(p); }
        public Iterator() { }

        public native @Name("operator++") @ByRef Iterator increment();
        public native @Name("operator==") boolean equals(@ByRef Iterator it);
        public native @Name("operator*().first") @MemberGetter @StdString BytePointer first();
        public native @Name("operator*().second") @MemberGetter DoubleLayerRegistry.Creator second();
    }
}

@Name("std::map") public static class StringIntMap extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public StringIntMap(Pointer p) { super(p); }
    public StringIntMap()       { allocate();  }
    private native void allocate();
    public native @Name("operator=") @ByRef StringIntMap put(@ByRef StringIntMap x);

    public native long size();

    @Index public native int get(@StdString BytePointer i);
    public native StringIntMap put(@StdString BytePointer i, int value);

    public native @ByVal Iterator begin();
    public native @ByVal Iterator end();
    @NoOffset @Name("iterator") public static class Iterator extends Pointer {
        public Iterator(Pointer p) { super(p); }
        public Iterator() { }

        public native @Name("operator++") @ByRef Iterator increment();
        public native @Name("operator==") boolean equals(@ByRef Iterator it);
        public native @Name("operator*().first") @MemberGetter @StdString BytePointer first();
        public native @Name("operator*().second") @MemberGetter int second();
    }
}

@Name("std::vector") public static class StringVector extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public StringVector(Pointer p) { super(p); }
    public StringVector(BytePointer ... array) { this(array.length); put(array); }
    public StringVector()       { allocate();  }
    public StringVector(long n) { allocate(n); }
    private native void allocate();
    private native void allocate(@Cast("size_t") long n);
    public native @Name("operator=") @ByRef StringVector put(@ByRef StringVector x);

    public native long size();
    public native void resize(@Cast("size_t") long n);

    @Index public native @StdString BytePointer get(@Cast("size_t") long i);
    public native StringVector put(@Cast("size_t") long i, BytePointer value);

    public StringVector put(BytePointer ... array) {
        if (size() != array.length) { resize(array.length); }
        for (int i = 0; i < array.length; i++) {
            put(i, array[i]);
        }
        return this;
    }
}

@Name("std::vector > >") public static class FloatBlobSharedVector extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public FloatBlobSharedVector(Pointer p) { super(p); }
    public FloatBlobSharedVector(FloatBlob ... array) { this(array.length); put(array); }
    public FloatBlobSharedVector()       { allocate();  }
    public FloatBlobSharedVector(long n) { allocate(n); }
    private native void allocate();
    private native void allocate(@Cast("size_t") long n);
    public native @Name("operator=") @ByRef FloatBlobSharedVector put(@ByRef FloatBlobSharedVector x);

    public native long size();
    public native void resize(@Cast("size_t") long n);

    @Index public native @SharedPtr FloatBlob get(@Cast("size_t") long i);
    public native FloatBlobSharedVector put(@Cast("size_t") long i, FloatBlob value);

    public FloatBlobSharedVector put(FloatBlob ... array) {
        if (size() != array.length) { resize(array.length); }
        for (int i = 0; i < array.length; i++) {
            put(i, array[i]);
        }
        return this;
    }
}

@Name("std::vector > >") public static class DoubleBlobSharedVector extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public DoubleBlobSharedVector(Pointer p) { super(p); }
    public DoubleBlobSharedVector(DoubleBlob ... array) { this(array.length); put(array); }
    public DoubleBlobSharedVector()       { allocate();  }
    public DoubleBlobSharedVector(long n) { allocate(n); }
    private native void allocate();
    private native void allocate(@Cast("size_t") long n);
    public native @Name("operator=") @ByRef DoubleBlobSharedVector put(@ByRef DoubleBlobSharedVector x);

    public native long size();
    public native void resize(@Cast("size_t") long n);

    @Index public native @SharedPtr DoubleBlob get(@Cast("size_t") long i);
    public native DoubleBlobSharedVector put(@Cast("size_t") long i, DoubleBlob value);

    public DoubleBlobSharedVector put(DoubleBlob ... array) {
        if (size() != array.length) { resize(array.length); }
        for (int i = 0; i < array.length; i++) {
            put(i, array[i]);
        }
        return this;
    }
}

@Name("std::vector > >") public static class FloatLayerSharedVector extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public FloatLayerSharedVector(Pointer p) { super(p); }
    public FloatLayerSharedVector(FloatLayer ... array) { this(array.length); put(array); }
    public FloatLayerSharedVector()       { allocate();  }
    public FloatLayerSharedVector(long n) { allocate(n); }
    private native void allocate();
    private native void allocate(@Cast("size_t") long n);
    public native @Name("operator=") @ByRef FloatLayerSharedVector put(@ByRef FloatLayerSharedVector x);

    public native long size();
    public native void resize(@Cast("size_t") long n);

    @Index public native @Cast({"", "boost::shared_ptr >"}) @SharedPtr FloatLayer get(@Cast("size_t") long i);
    public native FloatLayerSharedVector put(@Cast("size_t") long i, FloatLayer value);

    public FloatLayerSharedVector put(FloatLayer ... array) {
        if (size() != array.length) { resize(array.length); }
        for (int i = 0; i < array.length; i++) {
            put(i, array[i]);
        }
        return this;
    }
}

@Name("std::vector > >") public static class DoubleLayerSharedVector extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public DoubleLayerSharedVector(Pointer p) { super(p); }
    public DoubleLayerSharedVector(DoubleLayer ... array) { this(array.length); put(array); }
    public DoubleLayerSharedVector()       { allocate();  }
    public DoubleLayerSharedVector(long n) { allocate(n); }
    private native void allocate();
    private native void allocate(@Cast("size_t") long n);
    public native @Name("operator=") @ByRef DoubleLayerSharedVector put(@ByRef DoubleLayerSharedVector x);

    public native long size();
    public native void resize(@Cast("size_t") long n);

    @Index public native @Cast({"", "boost::shared_ptr >"}) @SharedPtr DoubleLayer get(@Cast("size_t") long i);
    public native DoubleLayerSharedVector put(@Cast("size_t") long i, DoubleLayer value);

    public DoubleLayerSharedVector put(DoubleLayer ... array) {
        if (size() != array.length) { resize(array.length); }
        for (int i = 0; i < array.length; i++) {
            put(i, array[i]);
        }
        return this;
    }
}

@Name("std::vector > >") public static class FloatNetSharedVector extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public FloatNetSharedVector(Pointer p) { super(p); }
    public FloatNetSharedVector(FloatNet ... array) { this(array.length); put(array); }
    public FloatNetSharedVector()       { allocate();  }
    public FloatNetSharedVector(long n) { allocate(n); }
    private native void allocate();
    private native void allocate(@Cast("size_t") long n);
    public native @Name("operator=") @ByRef FloatNetSharedVector put(@ByRef FloatNetSharedVector x);

    public native long size();
    public native void resize(@Cast("size_t") long n);

    @Index public native @SharedPtr FloatNet get(@Cast("size_t") long i);
    public native FloatNetSharedVector put(@Cast("size_t") long i, FloatNet value);

    public FloatNetSharedVector put(FloatNet ... array) {
        if (size() != array.length) { resize(array.length); }
        for (int i = 0; i < array.length; i++) {
            put(i, array[i]);
        }
        return this;
    }
}

@Name("std::vector > >") public static class DoubleNetSharedVector extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public DoubleNetSharedVector(Pointer p) { super(p); }
    public DoubleNetSharedVector(DoubleNet ... array) { this(array.length); put(array); }
    public DoubleNetSharedVector()       { allocate();  }
    public DoubleNetSharedVector(long n) { allocate(n); }
    private native void allocate();
    private native void allocate(@Cast("size_t") long n);
    public native @Name("operator=") @ByRef DoubleNetSharedVector put(@ByRef DoubleNetSharedVector x);

    public native long size();
    public native void resize(@Cast("size_t") long n);

    @Index public native @SharedPtr DoubleNet get(@Cast("size_t") long i);
    public native DoubleNetSharedVector put(@Cast("size_t") long i, DoubleNet value);

    public DoubleNetSharedVector put(DoubleNet ... array) {
        if (size() != array.length) { resize(array.length); }
        for (int i = 0; i < array.length; i++) {
            put(i, array[i]);
        }
        return this;
    }
}

@Name("std::vector*>") public static class FloatBlobVector extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public FloatBlobVector(Pointer p) { super(p); }
    public FloatBlobVector(FloatBlob ... array) { this(array.length); put(array); }
    public FloatBlobVector()       { allocate();  }
    public FloatBlobVector(long n) { allocate(n); }
    private native void allocate();
    private native void allocate(@Cast("size_t") long n);
    public native @Name("operator=") @ByRef FloatBlobVector put(@ByRef FloatBlobVector x);

    public native long size();
    public native void resize(@Cast("size_t") long n);

    @Index public native FloatBlob get(@Cast("size_t") long i);
    public native FloatBlobVector put(@Cast("size_t") long i, FloatBlob value);

    public FloatBlobVector put(FloatBlob ... array) {
        if (size() != array.length) { resize(array.length); }
        for (int i = 0; i < array.length; i++) {
            put(i, array[i]);
        }
        return this;
    }
}

@Name("std::vector*>") public static class DoubleBlobVector extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public DoubleBlobVector(Pointer p) { super(p); }
    public DoubleBlobVector(DoubleBlob ... array) { this(array.length); put(array); }
    public DoubleBlobVector()       { allocate();  }
    public DoubleBlobVector(long n) { allocate(n); }
    private native void allocate();
    private native void allocate(@Cast("size_t") long n);
    public native @Name("operator=") @ByRef DoubleBlobVector put(@ByRef DoubleBlobVector x);

    public native long size();
    public native void resize(@Cast("size_t") long n);

    @Index public native DoubleBlob get(@Cast("size_t") long i);
    public native DoubleBlobVector put(@Cast("size_t") long i, DoubleBlob value);

    public DoubleBlobVector put(DoubleBlob ... array) {
        if (size() != array.length) { resize(array.length); }
        for (int i = 0; i < array.length; i++) {
            put(i, array[i]);
        }
        return this;
    }
}

@Name("std::vector*> >") public static class FloatBlobVectorVector extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public FloatBlobVectorVector(Pointer p) { super(p); }
    public FloatBlobVectorVector(FloatBlobVector ... array) { this(array.length); put(array); }
    public FloatBlobVectorVector()       { allocate();  }
    public FloatBlobVectorVector(long n) { allocate(n); }
    private native void allocate();
    private native void allocate(@Cast("size_t") long n);
    public native @Name("operator=") @ByRef FloatBlobVectorVector put(@ByRef FloatBlobVectorVector x);

    public native long size();
    public native void resize(@Cast("size_t") long n);

    @Index public native @ByRef FloatBlobVector get(@Cast("size_t") long i);
    public native FloatBlobVectorVector put(@Cast("size_t") long i, FloatBlobVector value);

    public FloatBlobVectorVector put(FloatBlobVector ... array) {
        if (size() != array.length) { resize(array.length); }
        for (int i = 0; i < array.length; i++) {
            put(i, array[i]);
        }
        return this;
    }
}

@Name("std::vector*> >") public static class DoubleBlobVectorVector extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public DoubleBlobVectorVector(Pointer p) { super(p); }
    public DoubleBlobVectorVector(DoubleBlobVector ... array) { this(array.length); put(array); }
    public DoubleBlobVectorVector()       { allocate();  }
    public DoubleBlobVectorVector(long n) { allocate(n); }
    private native void allocate();
    private native void allocate(@Cast("size_t") long n);
    public native @Name("operator=") @ByRef DoubleBlobVectorVector put(@ByRef DoubleBlobVectorVector x);

    public native long size();
    public native void resize(@Cast("size_t") long n);

    @Index public native @ByRef DoubleBlobVector get(@Cast("size_t") long i);
    public native DoubleBlobVectorVector put(@Cast("size_t") long i, DoubleBlobVector value);

    public DoubleBlobVectorVector put(DoubleBlobVector ... array) {
        if (size() != array.length) { resize(array.length); }
        for (int i = 0; i < array.length; i++) {
            put(i, array[i]);
        }
        return this;
    }
}

@Name("std::vector") public static class BoolVector extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public BoolVector(Pointer p) { super(p); }
    public BoolVector(boolean ... array) { this(array.length); put(array); }
    public BoolVector()       { allocate();  }
    public BoolVector(long n) { allocate(n); }
    private native void allocate();
    private native void allocate(@Cast("size_t") long n);
    public native @Name("operator=") @ByRef BoolVector put(@ByRef BoolVector x);

    public native long size();
    public native void resize(@Cast("size_t") long n);

    @Index public native boolean get(@Cast("size_t") long i);
    public native BoolVector put(@Cast("size_t") long i, boolean value);

    public BoolVector put(boolean ... array) {
        if (size() != array.length) { resize(array.length); }
        for (int i = 0; i < array.length; i++) {
            put(i, array[i]);
        }
        return this;
    }
}

@Name("std::vector >") public static class BoolVectorVector extends Pointer {
    static { Loader.load(); }
    /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
    public BoolVectorVector(Pointer p) { super(p); }
    public BoolVectorVector(BoolVector ... array) { this(array.length); put(array); }
    public BoolVectorVector()       { allocate();  }
    public BoolVectorVector(long n) { allocate(n); }
    private native void allocate();
    private native void allocate(@Cast("size_t") long n);
    public native @Name("operator=") @ByRef BoolVectorVector put(@ByRef BoolVectorVector x);

    public native long size();
    public native void resize(@Cast("size_t") long n);

    @Index public native @ByRef BoolVector get(@Cast("size_t") long i);
    public native BoolVectorVector put(@Cast("size_t") long i, BoolVector value);

    public BoolVectorVector put(BoolVector ... array) {
        if (size() != array.length) { resize(array.length); }
        for (int i = 0; i < array.length; i++) {
            put(i, array[i]);
        }
        return this;
    }
}

// Parsed from caffe/caffe.hpp

// caffe.hpp is the header file that you need to include in your code. It wraps
// all the internal caffe header files into one for simpler inclusion.

// #ifndef CAFFE_CAFFE_HPP_
// #define CAFFE_CAFFE_HPP_

// #include "caffe/blob.hpp"
// #include "caffe/common.hpp"
// #include "caffe/filler.hpp"
// #include "caffe/layer.hpp"
// #include "caffe/layer_factory.hpp"
// #include "caffe/net.hpp"
// #include "caffe/parallel.hpp"
// #include "caffe/proto/caffe.pb.h"
// #include "caffe/solver.hpp"
// #include "caffe/solver_factory.hpp"
// #include "caffe/util/benchmark.hpp"
// #include "caffe/util/io.hpp"
// #include "caffe/util/upgrade_proto.hpp"
// #include "caffe/vision_layers.hpp"

// #endif  // CAFFE_CAFFE_HPP_


// Parsed from caffe/util/device_alternate.hpp

// #ifndef CAFFE_UTIL_DEVICE_ALTERNATE_H_
// #define CAFFE_UTIL_DEVICE_ALTERNATE_H_

// #ifdef CPU_ONLY  // CPU-only Caffe.

// #include 

// Stub out GPU calls as unavailable.

// #define NO_GPU LOG(FATAL) << "Cannot use GPU in CPU-only Caffe: check mode."

// #define STUB_GPU(classname)
// template 
// void classname::Forward_gpu(const vector*>& bottom,
//     const vector*>& top) { NO_GPU; }
// template 
// void classname::Backward_gpu(const vector*>& top,
//     const vector& propagate_down,
//     const vector*>& bottom) { NO_GPU; } 

// #define STUB_GPU_FORWARD(classname, funcname)
// template 
// void classname::funcname##_##gpu(const vector*>& bottom,
//     const vector*>& top) { NO_GPU; } 

// #define STUB_GPU_BACKWARD(classname, funcname)
// template 
// void classname::funcname##_##gpu(const vector*>& top,
//     const vector& propagate_down,
//     const vector*>& bottom) { NO_GPU; } 

// #else  // Normal GPU + CPU Caffe.

// #endif  // CPU_ONLY

// #endif  // CAFFE_UTIL_DEVICE_ALTERNATE_H_


// Parsed from caffe/common.hpp

// #ifndef CAFFE_COMMON_HPP_
// #define CAFFE_COMMON_HPP_

// #include 
// #include 
// #include 

// #include 
// #include 
// #include   // NOLINT(readability/streams)
// #include   // NOLINT(readability/streams)
// #include