repo stringlengths 1 191 ⌀ | file stringlengths 23 351 | code stringlengths 0 5.32M | file_length int64 0 5.32M | avg_line_length float64 0 2.9k | max_line_length int64 0 288k | extension_type stringclasses 1 value |
|---|---|---|---|---|---|---|
OpenStaticAnalyzer | OpenStaticAnalyzer-master/java/lib/java/src/main/java/columbus/java/asg/struc/InterfaceDeclaration.java | /*
* This file is part of OpenStaticAnalyzer.
*
* Copyright (c) 2004-2018 Department of Software Engineering - University of Szeged
*
* Licensed under Version 1.2 of the EUPL (the "Licence");
*
* You may not use this work except in compliance with the Licence.
*
* You may obtain a copy of the Licence in the LICENSE file or at:
*
* https://joinup.ec.europa.eu/software/page/eupl
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the Licence is distributed on an "AS IS" basis,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the Licence for the specific language governing permissions and
* limitations under the Licence.
*/
package columbus.java.asg.struc;
/**
* Interface InterfaceDeclaration, which represents the {@link columbus.java.asg.struc.InterfaceDeclaration InterfaceDeclaration} node.
* @columbus.node (missing)
*/
public interface InterfaceDeclaration extends TypeDeclaration {
}
| 1,006 | 30.46875 | 135 | java |
OpenStaticAnalyzer | OpenStaticAnalyzer-master/java/lib/java/src/main/java/columbus/java/asg/struc/TypeParameter.java | /*
* This file is part of OpenStaticAnalyzer.
*
* Copyright (c) 2004-2018 Department of Software Engineering - University of Szeged
*
* Licensed under Version 1.2 of the EUPL (the "Licence");
*
* You may not use this work except in compliance with the Licence.
*
* You may obtain a copy of the Licence in the LICENSE file or at:
*
* https://joinup.ec.europa.eu/software/page/eupl
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the Licence is distributed on an "AS IS" basis,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the Licence for the specific language governing permissions and
* limitations under the Licence.
*/
package columbus.java.asg.struc;
import columbus.java.asg.*;
import columbus.java.asg.expr.TypeExpression;
import columbus.java.asg.base.Positioned;
import columbus.java.asg.base.Named;
/**
* Interface TypeParameter, which represents the {@link columbus.java.asg.struc.TypeParameter TypeParameter} node.
* @columbus.node (missing)
* @columbus.edge hasBounds ({@link columbus.java.asg.expr.TypeExpression TypeExpression}, multiple) : (missing)
*/
public interface TypeParameter extends Positioned, Named {
/**
* Gives back iterator for the {@link columbus.java.asg.struc.TypeParameter#edgeHasBounds hasBounds} edges.
* @return Returns an iterator for the hasBounds edges.
*/
public EdgeIterator<TypeExpression> getBoundsIterator();
/**
* Tells whether the node has {@link columbus.java.asg.struc.TypeParameter#edgeHasBounds hasBounds} edges or not.
* @return Returns true if the node doesn't have any hasBounds edge.
*/
public boolean getBoundsIsEmpty();
/**
* Gives back how many {@link columbus.java.asg.struc.TypeParameter#edgeHasBounds hasBounds} edges the node has.
* @return Returns with the number of hasBounds edges.
*/
public int getBoundsSize();
/**
* Adds a new {@link columbus.java.asg.struc.TypeParameter#edgeHasBounds hasBounds} edge to the node.
* @param id The end point of the new hasBounds edge.
*/
public void addBounds(int id);
/**
* Adds a new {@link columbus.java.asg.struc.TypeParameter#edgeHasBounds hasBounds} edge to the node.
* @param node The end point of the new hasBounds edge.
*/
public void addBounds(TypeExpression node);
}
| 2,340 | 33.940299 | 114 | java |
OpenStaticAnalyzer | OpenStaticAnalyzer-master/java/lib/java/src/main/java/columbus/java/asg/struc/EnumConstant.java | /*
* This file is part of OpenStaticAnalyzer.
*
* Copyright (c) 2004-2018 Department of Software Engineering - University of Szeged
*
* Licensed under Version 1.2 of the EUPL (the "Licence");
*
* You may not use this work except in compliance with the Licence.
*
* You may obtain a copy of the Licence in the LICENSE file or at:
*
* https://joinup.ec.europa.eu/software/page/eupl
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the Licence is distributed on an "AS IS" basis,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the Licence for the specific language governing permissions and
* limitations under the Licence.
*/
package columbus.java.asg.struc;
import columbus.java.asg.expr.NewClass;
/**
* Interface EnumConstant, which represents the {@link columbus.java.asg.struc.EnumConstant EnumConstant} node.
* @columbus.node (missing)
* @columbus.edge hasNewClass ({@link columbus.java.asg.expr.NewClass NewClass}, single) : (missing)
*/
public interface EnumConstant extends VariableDeclaration {
/**
* Gives back the reference of the node the {@link columbus.java.asg.struc.EnumConstant#edgeHasNewClass hasNewClass} edge points to.
* @return Returns the end point of the hasNewClass edge.
*/
public NewClass getNewClass();
/**
* Sets the {@link columbus.java.asg.struc.EnumConstant#edgeHasNewClass hasNewClass} edge.
* @param id The new end point of the hasNewClass edge.
*/
public void setNewClass(int id);
/**
* Sets the {@link columbus.java.asg.struc.EnumConstant#edgeHasNewClass hasNewClass} edge.
* @param node The new end point of the hasNewClass edge.
*/
public void setNewClass(NewClass node);
}
| 1,752 | 32.711538 | 133 | java |
OpenStaticAnalyzer | OpenStaticAnalyzer-master/java/lib/java/src/main/java/columbus/java/asg/struc/StaticInitializerBlock.java | /*
* This file is part of OpenStaticAnalyzer.
*
* Copyright (c) 2004-2018 Department of Software Engineering - University of Szeged
*
* Licensed under Version 1.2 of the EUPL (the "Licence");
*
* You may not use this work except in compliance with the Licence.
*
* You may obtain a copy of the Licence in the LICENSE file or at:
*
* https://joinup.ec.europa.eu/software/page/eupl
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the Licence is distributed on an "AS IS" basis,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the Licence for the specific language governing permissions and
* limitations under the Licence.
*/
package columbus.java.asg.struc;
import columbus.java.asg.*;
/**
* Interface StaticInitializerBlock, which represents the {@link columbus.java.asg.struc.StaticInitializerBlock StaticInitializerBlock} node.
* @columbus.node (missing)
* @columbus.attr blockStartPosition (Range) : (missing)
*/
public interface StaticInitializerBlock extends InitializerBlock {
/**
* Gives back the {@link columbus.java.asg.struc.StaticInitializerBlock#attributeBlockStartPosition blockStartPosition} of the node.
* @return Returns with the blockStartPosition.
*/
public Range getBlockStartPosition();
/**
* Sets the {@link columbus.java.asg.struc.StaticInitializerBlock#attributeBlockStartPosition blockStartPosition} of the node.
* @param value The new value of the blockStartPosition.
*/
public void setBlockStartPosition(Range value);
}
| 1,579 | 33.347826 | 141 | java |
OpenStaticAnalyzer | OpenStaticAnalyzer-master/java/lib/java/src/main/java/columbus/java/asg/struc/Variable.java | /*
* This file is part of OpenStaticAnalyzer.
*
* Copyright (c) 2004-2018 Department of Software Engineering - University of Szeged
*
* Licensed under Version 1.2 of the EUPL (the "Licence");
*
* You may not use this work except in compliance with the Licence.
*
* You may obtain a copy of the Licence in the LICENSE file or at:
*
* https://joinup.ec.europa.eu/software/page/eupl
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the Licence is distributed on an "AS IS" basis,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the Licence for the specific language governing permissions and
* limitations under the Licence.
*/
package columbus.java.asg.struc;
import columbus.java.asg.*;
import columbus.java.asg.expr.Expression;
/**
* Interface Variable, which represents the {@link columbus.java.asg.struc.Variable Variable} node.
* @columbus.node (missing)
* @columbus.attr isTransient (boolean) : (missing)
* @columbus.attr transientPosition (Range) : (missing)
* @columbus.attr isVolatile (boolean) : (missing)
* @columbus.attr volatilePosition (Range) : (missing)
* @columbus.attr equalSignPosition (Range) : (missing)
* @columbus.edge hasInitialValue ({@link columbus.java.asg.expr.Expression Expression}, single) : (missing)
*/
public interface Variable extends VariableDeclaration {
/**
* Gives back the {@link columbus.java.asg.struc.Variable#attributeIsTransient isTransient} of the node.
* @return Returns with the isTransient.
*/
public boolean getIsTransient();
/**
* Sets the {@link columbus.java.asg.struc.Variable#attributeIsTransient isTransient} of the node.
* @param value The new value of the isTransient.
*/
public void setIsTransient(boolean value);
/**
* Gives back the {@link columbus.java.asg.struc.Variable#attributeTransientPosition transientPosition} of the node.
* @return Returns with the transientPosition.
*/
public Range getTransientPosition();
/**
* Sets the {@link columbus.java.asg.struc.Variable#attributeTransientPosition transientPosition} of the node.
* @param value The new value of the transientPosition.
*/
public void setTransientPosition(Range value);
/**
* Gives back the {@link columbus.java.asg.struc.Variable#attributeIsVolatile isVolatile} of the node.
* @return Returns with the isVolatile.
*/
public boolean getIsVolatile();
/**
* Sets the {@link columbus.java.asg.struc.Variable#attributeIsVolatile isVolatile} of the node.
* @param value The new value of the isVolatile.
*/
public void setIsVolatile(boolean value);
/**
* Gives back the {@link columbus.java.asg.struc.Variable#attributeVolatilePosition volatilePosition} of the node.
* @return Returns with the volatilePosition.
*/
public Range getVolatilePosition();
/**
* Sets the {@link columbus.java.asg.struc.Variable#attributeVolatilePosition volatilePosition} of the node.
* @param value The new value of the volatilePosition.
*/
public void setVolatilePosition(Range value);
/**
* Gives back the {@link columbus.java.asg.struc.Variable#attributeEqualSignPosition equalSignPosition} of the node.
* @return Returns with the equalSignPosition.
*/
public Range getEqualSignPosition();
/**
* Sets the {@link columbus.java.asg.struc.Variable#attributeEqualSignPosition equalSignPosition} of the node.
* @param value The new value of the equalSignPosition.
*/
public void setEqualSignPosition(Range value);
/**
* Gives back the reference of the node the {@link columbus.java.asg.struc.Variable#edgeHasInitialValue hasInitialValue} edge points to.
* @return Returns the end point of the hasInitialValue edge.
*/
public Expression getInitialValue();
/**
* Sets the {@link columbus.java.asg.struc.Variable#edgeHasInitialValue hasInitialValue} edge.
* @param id The new end point of the hasInitialValue edge.
*/
public void setInitialValue(int id);
/**
* Sets the {@link columbus.java.asg.struc.Variable#edgeHasInitialValue hasInitialValue} edge.
* @param node The new end point of the hasInitialValue edge.
*/
public void setInitialValue(Expression node);
}
| 4,195 | 34.559322 | 137 | java |
OpenStaticAnalyzer | OpenStaticAnalyzer-master/java/lib/java/src/main/java/columbus/java/asg/struc/Import.java | /*
* This file is part of OpenStaticAnalyzer.
*
* Copyright (c) 2004-2018 Department of Software Engineering - University of Szeged
*
* Licensed under Version 1.2 of the EUPL (the "Licence");
*
* You may not use this work except in compliance with the Licence.
*
* You may obtain a copy of the Licence in the LICENSE file or at:
*
* https://joinup.ec.europa.eu/software/page/eupl
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the Licence is distributed on an "AS IS" basis,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the Licence for the specific language governing permissions and
* limitations under the Licence.
*/
package columbus.java.asg.struc;
import columbus.java.asg.*;
import columbus.java.asg.expr.Expression;
import columbus.java.asg.base.Positioned;
/**
* Interface Import, which represents the {@link columbus.java.asg.struc.Import Import} node.
* @columbus.node (missing)
* @columbus.attr isStatic (boolean) : (missing)
* @columbus.attr staticPosition (Range) : (missing)
* @columbus.edge hasTarget ({@link columbus.java.asg.expr.Expression Expression}, single) : (missing)
*/
public interface Import extends Positioned {
/**
* Gives back the {@link columbus.java.asg.struc.Import#attributeIsStatic isStatic} of the node.
* @return Returns with the isStatic.
*/
public boolean getIsStatic();
/**
* Sets the {@link columbus.java.asg.struc.Import#attributeIsStatic isStatic} of the node.
* @param value The new value of the isStatic.
*/
public void setIsStatic(boolean value);
/**
* Gives back the {@link columbus.java.asg.struc.Import#attributeStaticPosition staticPosition} of the node.
* @return Returns with the staticPosition.
*/
public Range getStaticPosition();
/**
* Sets the {@link columbus.java.asg.struc.Import#attributeStaticPosition staticPosition} of the node.
* @param value The new value of the staticPosition.
*/
public void setStaticPosition(Range value);
/**
* Gives back the reference of the node the {@link columbus.java.asg.struc.Import#edgeHasTarget hasTarget} edge points to.
* @return Returns the end point of the hasTarget edge.
*/
public Expression getTarget();
/**
* Sets the {@link columbus.java.asg.struc.Import#edgeHasTarget hasTarget} edge.
* @param id The new end point of the hasTarget edge.
*/
public void setTarget(int id);
/**
* Sets the {@link columbus.java.asg.struc.Import#edgeHasTarget hasTarget} edge.
* @param node The new end point of the hasTarget edge.
*/
public void setTarget(Expression node);
}
| 2,643 | 32.05 | 123 | java |
OpenStaticAnalyzer | OpenStaticAnalyzer-master/java/lib/java/src/main/java/columbus/java/asg/struc/Scope.java | /*
* This file is part of OpenStaticAnalyzer.
*
* Copyright (c) 2004-2018 Department of Software Engineering - University of Szeged
*
* Licensed under Version 1.2 of the EUPL (the "Licence");
*
* You may not use this work except in compliance with the Licence.
*
* You may obtain a copy of the Licence in the LICENSE file or at:
*
* https://joinup.ec.europa.eu/software/page/eupl
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the Licence is distributed on an "AS IS" basis,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the Licence for the specific language governing permissions and
* limitations under the Licence.
*/
package columbus.java.asg.struc;
import columbus.java.asg.*;
/**
* Interface Scope, which represents the {@link columbus.java.asg.struc.Scope Scope} node.
* @columbus.node (missing)
* @columbus.edge hasMembers ({@link columbus.java.asg.struc.Member Member}, multiple) : (missing)
*/
public interface Scope extends Member {
/**
* Gives back iterator for the {@link columbus.java.asg.struc.Scope#edgeHasMembers hasMembers} edges.
* @return Returns an iterator for the hasMembers edges.
*/
public EdgeIterator<Member> getMembersIterator();
/**
* Tells whether the node has {@link columbus.java.asg.struc.Scope#edgeHasMembers hasMembers} edges or not.
* @return Returns true if the node doesn't have any hasMembers edge.
*/
public boolean getMembersIsEmpty();
/**
* Gives back how many {@link columbus.java.asg.struc.Scope#edgeHasMembers hasMembers} edges the node has.
* @return Returns with the number of hasMembers edges.
*/
public int getMembersSize();
/**
* Adds a new {@link columbus.java.asg.struc.Scope#edgeHasMembers hasMembers} edge to the node.
* @param id The end point of the new hasMembers edge.
*/
public void addMembers(int id);
/**
* Adds a new {@link columbus.java.asg.struc.Scope#edgeHasMembers hasMembers} edge to the node.
* @param node The end point of the new hasMembers edge.
*/
public void addMembers(Member node);
}
| 2,122 | 32.171875 | 108 | java |
OpenStaticAnalyzer | OpenStaticAnalyzer-master/java/lib/java/src/main/java/columbus/java/asg/struc/ClassImpl.java | /*
* This file is part of OpenStaticAnalyzer.
*
* Copyright (c) 2004-2018 Department of Software Engineering - University of Szeged
*
* Licensed under Version 1.2 of the EUPL (the "Licence");
*
* You may not use this work except in compliance with the Licence.
*
* You may obtain a copy of the Licence in the LICENSE file or at:
*
* https://joinup.ec.europa.eu/software/page/eupl
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the Licence is distributed on an "AS IS" basis,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the Licence for the specific language governing permissions and
* limitations under the Licence.
*/
package columbus.java.asg.struc;
import columbus.IO;
import columbus.java.asg.*;
import columbus.java.asg.base.BaseImpl;
import columbus.java.asg.base.Base;
import columbus.java.asg.expr.TypeExpression;
import columbus.java.asg.base.Positioned;
import columbus.java.asg.base.Comment;
import columbus.java.asg.expr.Annotation;
import columbus.java.asg.enums.*;
import columbus.java.asg.visitors.Visitor;
import columbus.logger.LoggerHandler;
/**
* Implementation class for the {@link columbus.java.asg.struc.Class Class} node.
* <p><b>WARNING: For internal use only.</b></p>
*/
public class ClassImpl extends BaseImpl implements Class {
@SuppressWarnings("unused")
private static final LoggerHandler logger = new LoggerHandler(ClassImpl.class, columbus.java.asg.Constant.LoggerPropertyFile);
protected EdgeList<Comment> _comments;
protected EdgeList<Annotation> _hasAnnotations;
protected Object position;
protected boolean isCompilerGenerated;
protected boolean isToolGenerated;
protected int name;
protected Object namePosition;
protected AccessibilityKind accessibility = AccessibilityKind.ackNone;
protected Object accessibilityPosition;
protected boolean isStatic;
protected Object staticPosition;
protected boolean isFinal;
protected Object finalPosition;
protected EdgeList<Member> _hasMembers;
protected int lloc;
protected Object typeNamePosition;
protected boolean isAbstract;
protected Object abstractPosition;
protected boolean isStrictfp;
protected Object strictfpPosition;
protected int binaryName;
protected Object extendsPosition;
protected Object implementsPosition;
protected Object bodyStartPosition;
protected int _hasSuperClass;
protected EdgeList<TypeExpression> _hasSuperInterfaces;
protected EdgeList<Positioned> _hasOthers;
protected int _isInCompilationUnit;
protected int _isInModule;
public ClassImpl(int id, Factory factory) {
super(id, factory);
position = new Range(factory.getStringTable());
namePosition = new Range(factory.getStringTable());
accessibilityPosition = new Range(factory.getStringTable());
staticPosition = new Range(factory.getStringTable());
finalPosition = new Range(factory.getStringTable());
typeNamePosition = new Range(factory.getStringTable());
abstractPosition = new Range(factory.getStringTable());
strictfpPosition = new Range(factory.getStringTable());
extendsPosition = new Range(factory.getStringTable());
implementsPosition = new Range(factory.getStringTable());
bodyStartPosition = new Range(factory.getStringTable());
}
@Override
public NodeKind getNodeKind() {
return NodeKind.ndkClass;
}
@Override
public Range getPosition() {
return (Range)position;
}
@Override
public void setPosition(Range _position) {
if (factory.getStringTable() == _position.getStringTable())
position = _position;
else
position = new Range(factory.getStringTable(), _position);
}
@Override
public boolean getIsCompilerGenerated() {
return isCompilerGenerated;
}
@Override
public boolean getIsToolGenerated() {
return isToolGenerated;
}
@Override
public void setIsCompilerGenerated(boolean _isCompilerGenerated) {
isCompilerGenerated = _isCompilerGenerated;
}
@Override
public void setIsToolGenerated(boolean _isToolGenerated) {
isToolGenerated = _isToolGenerated;
}
@Override
public String getName() {
return factory.getStringTable().get(name);
}
@Override
public int getNameKey() {
return name;
}
@Override
public Range getNamePosition() {
return (Range)namePosition;
}
@Override
public void setName(String _name) {
name = factory.getStringTable().set(_name);
}
@Override
public void setNamePosition(Range _namePosition) {
if (factory.getStringTable() == _namePosition.getStringTable())
namePosition = _namePosition;
else
namePosition = new Range(factory.getStringTable(), _namePosition);
}
@Override
public AccessibilityKind getAccessibility() {
return accessibility;
}
@Override
public Range getAccessibilityPosition() {
return (Range)accessibilityPosition;
}
@Override
public boolean getIsStatic() {
return isStatic;
}
@Override
public Range getStaticPosition() {
return (Range)staticPosition;
}
@Override
public boolean getIsFinal() {
return isFinal;
}
@Override
public Range getFinalPosition() {
return (Range)finalPosition;
}
@Override
public void setAccessibility(AccessibilityKind _accessibility) {
accessibility = _accessibility;
}
@Override
public void setAccessibilityPosition(Range _accessibilityPosition) {
if (factory.getStringTable() == _accessibilityPosition.getStringTable())
accessibilityPosition = _accessibilityPosition;
else
accessibilityPosition = new Range(factory.getStringTable(), _accessibilityPosition);
}
@Override
public void setIsStatic(boolean _isStatic) {
isStatic = _isStatic;
}
@Override
public void setStaticPosition(Range _staticPosition) {
if (factory.getStringTable() == _staticPosition.getStringTable())
staticPosition = _staticPosition;
else
staticPosition = new Range(factory.getStringTable(), _staticPosition);
}
@Override
public void setIsFinal(boolean _isFinal) {
isFinal = _isFinal;
}
@Override
public void setFinalPosition(Range _finalPosition) {
if (factory.getStringTable() == _finalPosition.getStringTable())
finalPosition = _finalPosition;
else
finalPosition = new Range(factory.getStringTable(), _finalPosition);
}
@Override
public int getLloc() {
return lloc;
}
@Override
public Range getTypeNamePosition() {
return (Range)typeNamePosition;
}
@Override
public boolean getIsAbstract() {
return isAbstract;
}
@Override
public Range getAbstractPosition() {
return (Range)abstractPosition;
}
@Override
public boolean getIsStrictfp() {
return isStrictfp;
}
@Override
public Range getStrictfpPosition() {
return (Range)strictfpPosition;
}
@Override
public String getBinaryName() {
return factory.getStringTable().get(binaryName);
}
@Override
public int getBinaryNameKey() {
return binaryName;
}
@Override
public Range getExtendsPosition() {
return (Range)extendsPosition;
}
@Override
public Range getImplementsPosition() {
return (Range)implementsPosition;
}
@Override
public Range getBodyStartPosition() {
return (Range)bodyStartPosition;
}
@Override
public void setLloc(int _lloc) {
lloc = _lloc;
}
@Override
public void setTypeNamePosition(Range _typeNamePosition) {
if (factory.getStringTable() == _typeNamePosition.getStringTable())
typeNamePosition = _typeNamePosition;
else
typeNamePosition = new Range(factory.getStringTable(), _typeNamePosition);
}
@Override
public void setIsAbstract(boolean _isAbstract) {
isAbstract = _isAbstract;
}
@Override
public void setAbstractPosition(Range _abstractPosition) {
if (factory.getStringTable() == _abstractPosition.getStringTable())
abstractPosition = _abstractPosition;
else
abstractPosition = new Range(factory.getStringTable(), _abstractPosition);
}
@Override
public void setIsStrictfp(boolean _isStrictfp) {
isStrictfp = _isStrictfp;
}
@Override
public void setStrictfpPosition(Range _strictfpPosition) {
if (factory.getStringTable() == _strictfpPosition.getStringTable())
strictfpPosition = _strictfpPosition;
else
strictfpPosition = new Range(factory.getStringTable(), _strictfpPosition);
}
@Override
public void setBinaryName(String _binaryName) {
binaryName = factory.getStringTable().set(_binaryName);
}
@Override
public void setExtendsPosition(Range _extendsPosition) {
if (factory.getStringTable() == _extendsPosition.getStringTable())
extendsPosition = _extendsPosition;
else
extendsPosition = new Range(factory.getStringTable(), _extendsPosition);
}
@Override
public void setImplementsPosition(Range _implementsPosition) {
if (factory.getStringTable() == _implementsPosition.getStringTable())
implementsPosition = _implementsPosition;
else
implementsPosition = new Range(factory.getStringTable(), _implementsPosition);
}
@Override
public void setBodyStartPosition(Range _bodyStartPosition) {
if (factory.getStringTable() == _bodyStartPosition.getStringTable())
bodyStartPosition = _bodyStartPosition;
else
bodyStartPosition = new Range(factory.getStringTable(), _bodyStartPosition);
}
@Override
public EdgeIterator<Comment> getCommentsIterator() {
if (_comments == null)
return EdgeList.<Comment>emptyList().iterator();
else
return _comments.iterator();
}
@Override
public boolean getCommentsIsEmpty() {
if (_comments == null)
return true;
else
return _comments.isEmpty();
}
@Override
public int getCommentsSize() {
if (_comments == null)
return 0;
else
return _comments.size();
}
@Override
public void addComments(int _id) {
if (!factory.getExist(_id))
throw new JavaException(logger.formatMessage("ex.java.Node.No_end_point"));
Base _node = factory.getRef(_id);
if (Common.getIsBaseClassKind(_node.getNodeKind(), NodeKind.ndkComment)) {
if (_comments == null)
_comments = new EdgeList<Comment>(factory);
_comments.add(_id);
} else {
throw new JavaException(logger.formatMessage("ex.java.Node.Invalid","NodeKind", _node.getNodeKind() ));
}
}
@Override
public void addComments(Comment _node) {
if (_comments == null)
_comments = new EdgeList<Comment>(factory);
_comments.add(_node);
}
@Override
public EdgeIterator<Annotation> getAnnotationsIterator() {
if (_hasAnnotations == null)
return EdgeList.<Annotation>emptyList().iterator();
else
return _hasAnnotations.iterator();
}
@Override
public boolean getAnnotationsIsEmpty() {
if (_hasAnnotations == null)
return true;
else
return _hasAnnotations.isEmpty();
}
@Override
public int getAnnotationsSize() {
if (_hasAnnotations == null)
return 0;
else
return _hasAnnotations.size();
}
@Override
public void addAnnotations(int _id) {
if (!factory.getExist(_id))
throw new JavaException(logger.formatMessage("ex.java.Node.No_end_point"));
Base _node = factory.getRef(_id);
if (Common.getIsBaseClassKind(_node.getNodeKind(), NodeKind.ndkAnnotation)) {
if (_hasAnnotations == null)
_hasAnnotations = new EdgeList<Annotation>(factory);
_hasAnnotations.add(_id);
} else {
throw new JavaException(logger.formatMessage("ex.java.Node.Invalid","NodeKind", _node.getNodeKind() ));
}
setParentEdge(_id);
}
@Override
public void addAnnotations(Annotation _node) {
if (_hasAnnotations == null)
_hasAnnotations = new EdgeList<Annotation>(factory);
_hasAnnotations.add(_node);
setParentEdge(_node);
}
@Override
public EdgeIterator<Member> getMembersIterator() {
if (_hasMembers == null)
return EdgeList.<Member>emptyList().iterator();
else
return _hasMembers.iterator();
}
@Override
public boolean getMembersIsEmpty() {
if (_hasMembers == null)
return true;
else
return _hasMembers.isEmpty();
}
@Override
public int getMembersSize() {
if (_hasMembers == null)
return 0;
else
return _hasMembers.size();
}
@Override
public void addMembers(int _id) {
if (!factory.getExist(_id))
throw new JavaException(logger.formatMessage("ex.java.Node.No_end_point"));
Base _node = factory.getRef(_id);
if (Common.getIsBaseClassKind(_node.getNodeKind(), NodeKind.ndkMember)) {
if (_hasMembers == null)
_hasMembers = new EdgeList<Member>(factory);
_hasMembers.add(_id);
} else {
throw new JavaException(logger.formatMessage("ex.java.Node.Invalid","NodeKind", _node.getNodeKind() ));
}
setParentEdge(_id);
}
@Override
public void addMembers(Member _node) {
if (_hasMembers == null)
_hasMembers = new EdgeList<Member>(factory);
_hasMembers.add(_node);
setParentEdge(_node);
}
@Override
public TypeExpression getSuperClass() {
if (_hasSuperClass == 0)
return null;
if (factory.getIsFiltered(_hasSuperClass))
return null;
return (TypeExpression)factory.getRef(_hasSuperClass);
}
@Override
public EdgeIterator<TypeExpression> getSuperInterfacesIterator() {
if (_hasSuperInterfaces == null)
return EdgeList.<TypeExpression>emptyList().iterator();
else
return _hasSuperInterfaces.iterator();
}
@Override
public boolean getSuperInterfacesIsEmpty() {
if (_hasSuperInterfaces == null)
return true;
else
return _hasSuperInterfaces.isEmpty();
}
@Override
public int getSuperInterfacesSize() {
if (_hasSuperInterfaces == null)
return 0;
else
return _hasSuperInterfaces.size();
}
@Override
public EdgeIterator<Positioned> getOthersIterator() {
if (_hasOthers == null)
return EdgeList.<Positioned>emptyList().iterator();
else
return _hasOthers.iterator();
}
@Override
public boolean getOthersIsEmpty() {
if (_hasOthers == null)
return true;
else
return _hasOthers.isEmpty();
}
@Override
public int getOthersSize() {
if (_hasOthers == null)
return 0;
else
return _hasOthers.size();
}
@Override
public CompilationUnit getIsInCompilationUnit() {
if (_isInCompilationUnit == 0)
return null;
if (factory.getIsFiltered(_isInCompilationUnit))
return null;
return (CompilationUnit)factory.getRef(_isInCompilationUnit);
}
@Override
public Module getIsInModule() {
if (_isInModule == 0)
return null;
if (factory.getIsFiltered(_isInModule))
return null;
return (Module)factory.getRef(_isInModule);
}
@Override
public void setSuperClass(int _id) {
if (_hasSuperClass != 0)
throw new JavaException(logger.formatMessage("ex.java.Node.The_previous_end_point","hasSuperClass" ));
if (!factory.getExist(_id))
throw new JavaException(logger.formatMessage("ex.java.Node.No_end_point"));
Base _node = factory.getRef(_id);
if (Common.getIsBaseClassKind(_node.getNodeKind(), NodeKind.ndkTypeExpression)) {
_hasSuperClass = _id;
setParentEdge(_hasSuperClass);
} else {
throw new JavaException(logger.formatMessage("ex.java.Node.Invalid","NodeKind", _node.getNodeKind() ));
}
}
@Override
public void setSuperClass(TypeExpression _node) {
if (_hasSuperClass != 0)
throw new JavaException(logger.formatMessage("ex.java.Node.The_previous_end_point","hasSuperClass" ));
_hasSuperClass = _node.getId();
setParentEdge(_hasSuperClass);
}
@Override
public void addSuperInterfaces(int _id) {
if (!factory.getExist(_id))
throw new JavaException(logger.formatMessage("ex.java.Node.No_end_point"));
Base _node = factory.getRef(_id);
if (Common.getIsBaseClassKind(_node.getNodeKind(), NodeKind.ndkTypeExpression)) {
if (_hasSuperInterfaces == null)
_hasSuperInterfaces = new EdgeList<TypeExpression>(factory);
_hasSuperInterfaces.add(_id);
} else {
throw new JavaException(logger.formatMessage("ex.java.Node.Invalid","NodeKind", _node.getNodeKind() ));
}
setParentEdge(_id);
}
@Override
public void addSuperInterfaces(TypeExpression _node) {
if (_hasSuperInterfaces == null)
_hasSuperInterfaces = new EdgeList<TypeExpression>(factory);
_hasSuperInterfaces.add(_node);
setParentEdge(_node);
}
@Override
public void addOthers(int _id) {
if (!factory.getExist(_id))
throw new JavaException(logger.formatMessage("ex.java.Node.No_end_point"));
Base _node = factory.getRef(_id);
if (Common.getIsBaseClassKind(_node.getNodeKind(), NodeKind.ndkPositioned)) {
if (_hasOthers == null)
_hasOthers = new EdgeList<Positioned>(factory);
_hasOthers.add(_id);
} else {
throw new JavaException(logger.formatMessage("ex.java.Node.Invalid","NodeKind", _node.getNodeKind() ));
}
setParentEdge(_id);
}
@Override
public void addOthers(Positioned _node) {
if (_hasOthers == null)
_hasOthers = new EdgeList<Positioned>(factory);
_hasOthers.add(_node);
setParentEdge(_node);
}
@Override
public void setIsInCompilationUnit(int _id) {
if (_isInCompilationUnit != 0)
throw new JavaException(logger.formatMessage("ex.java.Node.The_previous_end_point","isInCompilationUnit" ));
if (!factory.getExist(_id))
throw new JavaException(logger.formatMessage("ex.java.Node.No_end_point"));
Base _node = factory.getRef(_id);
if (_node.getNodeKind() == NodeKind.ndkCompilationUnit) {
_isInCompilationUnit = _id;
} else {
throw new JavaException(logger.formatMessage("ex.java.Node.Invalid","NodeKind", _node.getNodeKind() ));
}
}
@Override
public void setIsInCompilationUnit(CompilationUnit _node) {
if (_isInCompilationUnit != 0)
throw new JavaException(logger.formatMessage("ex.java.Node.The_previous_end_point","isInCompilationUnit" ));
_isInCompilationUnit = _node.getId();
}
@Override
public void setIsInModule(int _id) {
if (_isInModule != 0)
throw new JavaException(logger.formatMessage("ex.java.Node.The_previous_end_point","isInModule" ));
if (!factory.getExist(_id))
throw new JavaException(logger.formatMessage("ex.java.Node.No_end_point"));
Base _node = factory.getRef(_id);
if (_node.getNodeKind() == NodeKind.ndkModule) {
_isInModule = _id;
} else {
throw new JavaException(logger.formatMessage("ex.java.Node.Invalid","NodeKind", _node.getNodeKind() ));
}
}
@Override
public void setIsInModule(Module _node) {
if (_isInModule != 0)
throw new JavaException(logger.formatMessage("ex.java.Node.The_previous_end_point","isInModule" ));
_isInModule = _node.getId();
}
// ---------- Accept methods for Visitor ----------
@Override
public void accept(Visitor visitor) {
visitor.visit(this, true);
}
@Override
public void acceptEnd(Visitor visitor) {
visitor.visitEnd(this, true);
}
// ---------- Save ----------
@Override
public void save(IO io) {
io.writeInt4(id);
io.writeUShort2(getNodeKind().ordinal());
if (_comments != null) {
EdgeIterator<Comment> it = getCommentsIterator();
while (it.hasNext()) {
io.writeInt4(it.next().getId());
}
}
io.writeInt4(0);
if (_hasAnnotations != null) {
EdgeIterator<Annotation> it = getAnnotationsIterator();
while (it.hasNext()) {
io.writeInt4(it.next().getId());
}
}
io.writeInt4(0);
io.writeInt4(((Range)position).getPathKey());
io.writeInt4(((Range)position).getLine());
io.writeInt4(((Range)position).getCol());
io.writeInt4(((Range)position).getEndLine());
io.writeInt4(((Range)position).getEndCol());
io.writeInt4(((Range)position).getWideLine());
io.writeInt4(((Range)position).getWideCol());
io.writeInt4(((Range)position).getWideEndLine());
io.writeInt4(((Range)position).getWideEndCol());
{
byte boolValues = 0;
boolValues <<= 1;
if (isCompilerGenerated)
boolValues |= 1;
boolValues <<= 1;
if (isToolGenerated)
boolValues |= 1;
io.writeByte1(boolValues);
}
io.writeInt4(name);
io.writeInt4(((Range)namePosition).getPathKey());
io.writeInt4(((Range)namePosition).getLine());
io.writeInt4(((Range)namePosition).getCol());
io.writeInt4(((Range)namePosition).getEndLine());
io.writeInt4(((Range)namePosition).getEndCol());
io.writeInt4(((Range)namePosition).getWideLine());
io.writeInt4(((Range)namePosition).getWideCol());
io.writeInt4(((Range)namePosition).getWideEndLine());
io.writeInt4(((Range)namePosition).getWideEndCol());
{
byte boolValues = 0;
boolValues <<= 1;
if (isStatic)
boolValues |= 1;
boolValues <<= 1;
if (isFinal)
boolValues |= 1;
io.writeByte1(boolValues);
}
io.writeUByte1(accessibility.ordinal());
io.writeInt4(((Range)accessibilityPosition).getPathKey());
io.writeInt4(((Range)accessibilityPosition).getLine());
io.writeInt4(((Range)accessibilityPosition).getCol());
io.writeInt4(((Range)accessibilityPosition).getEndLine());
io.writeInt4(((Range)accessibilityPosition).getEndCol());
io.writeInt4(((Range)accessibilityPosition).getWideLine());
io.writeInt4(((Range)accessibilityPosition).getWideCol());
io.writeInt4(((Range)accessibilityPosition).getWideEndLine());
io.writeInt4(((Range)accessibilityPosition).getWideEndCol());
io.writeInt4(((Range)staticPosition).getPathKey());
io.writeInt4(((Range)staticPosition).getLine());
io.writeInt4(((Range)staticPosition).getCol());
io.writeInt4(((Range)staticPosition).getEndLine());
io.writeInt4(((Range)staticPosition).getEndCol());
io.writeInt4(((Range)staticPosition).getWideLine());
io.writeInt4(((Range)staticPosition).getWideCol());
io.writeInt4(((Range)staticPosition).getWideEndLine());
io.writeInt4(((Range)staticPosition).getWideEndCol());
io.writeInt4(((Range)finalPosition).getPathKey());
io.writeInt4(((Range)finalPosition).getLine());
io.writeInt4(((Range)finalPosition).getCol());
io.writeInt4(((Range)finalPosition).getEndLine());
io.writeInt4(((Range)finalPosition).getEndCol());
io.writeInt4(((Range)finalPosition).getWideLine());
io.writeInt4(((Range)finalPosition).getWideCol());
io.writeInt4(((Range)finalPosition).getWideEndLine());
io.writeInt4(((Range)finalPosition).getWideEndCol());
if (_hasMembers != null) {
EdgeIterator<Member> it = getMembersIterator();
while (it.hasNext()) {
io.writeInt4(it.next().getId());
}
}
io.writeInt4(0);
{
byte boolValues = 0;
boolValues <<= 1;
if (isAbstract)
boolValues |= 1;
boolValues <<= 1;
if (isStrictfp)
boolValues |= 1;
io.writeByte1(boolValues);
}
io.writeInt4(lloc);
io.writeInt4(((Range)typeNamePosition).getPathKey());
io.writeInt4(((Range)typeNamePosition).getLine());
io.writeInt4(((Range)typeNamePosition).getCol());
io.writeInt4(((Range)typeNamePosition).getEndLine());
io.writeInt4(((Range)typeNamePosition).getEndCol());
io.writeInt4(((Range)typeNamePosition).getWideLine());
io.writeInt4(((Range)typeNamePosition).getWideCol());
io.writeInt4(((Range)typeNamePosition).getWideEndLine());
io.writeInt4(((Range)typeNamePosition).getWideEndCol());
io.writeInt4(((Range)abstractPosition).getPathKey());
io.writeInt4(((Range)abstractPosition).getLine());
io.writeInt4(((Range)abstractPosition).getCol());
io.writeInt4(((Range)abstractPosition).getEndLine());
io.writeInt4(((Range)abstractPosition).getEndCol());
io.writeInt4(((Range)abstractPosition).getWideLine());
io.writeInt4(((Range)abstractPosition).getWideCol());
io.writeInt4(((Range)abstractPosition).getWideEndLine());
io.writeInt4(((Range)abstractPosition).getWideEndCol());
io.writeInt4(((Range)strictfpPosition).getPathKey());
io.writeInt4(((Range)strictfpPosition).getLine());
io.writeInt4(((Range)strictfpPosition).getCol());
io.writeInt4(((Range)strictfpPosition).getEndLine());
io.writeInt4(((Range)strictfpPosition).getEndCol());
io.writeInt4(((Range)strictfpPosition).getWideLine());
io.writeInt4(((Range)strictfpPosition).getWideCol());
io.writeInt4(((Range)strictfpPosition).getWideEndLine());
io.writeInt4(((Range)strictfpPosition).getWideEndCol());
io.writeInt4(binaryName);
io.writeInt4(((Range)extendsPosition).getPathKey());
io.writeInt4(((Range)extendsPosition).getLine());
io.writeInt4(((Range)extendsPosition).getCol());
io.writeInt4(((Range)extendsPosition).getEndLine());
io.writeInt4(((Range)extendsPosition).getEndCol());
io.writeInt4(((Range)extendsPosition).getWideLine());
io.writeInt4(((Range)extendsPosition).getWideCol());
io.writeInt4(((Range)extendsPosition).getWideEndLine());
io.writeInt4(((Range)extendsPosition).getWideEndCol());
io.writeInt4(((Range)implementsPosition).getPathKey());
io.writeInt4(((Range)implementsPosition).getLine());
io.writeInt4(((Range)implementsPosition).getCol());
io.writeInt4(((Range)implementsPosition).getEndLine());
io.writeInt4(((Range)implementsPosition).getEndCol());
io.writeInt4(((Range)implementsPosition).getWideLine());
io.writeInt4(((Range)implementsPosition).getWideCol());
io.writeInt4(((Range)implementsPosition).getWideEndLine());
io.writeInt4(((Range)implementsPosition).getWideEndCol());
io.writeInt4(((Range)bodyStartPosition).getPathKey());
io.writeInt4(((Range)bodyStartPosition).getLine());
io.writeInt4(((Range)bodyStartPosition).getCol());
io.writeInt4(((Range)bodyStartPosition).getEndLine());
io.writeInt4(((Range)bodyStartPosition).getEndCol());
io.writeInt4(((Range)bodyStartPosition).getWideLine());
io.writeInt4(((Range)bodyStartPosition).getWideCol());
io.writeInt4(((Range)bodyStartPosition).getWideEndLine());
io.writeInt4(((Range)bodyStartPosition).getWideEndCol());
io.writeInt4(!factory.getIsFiltered(_hasSuperClass) ? _hasSuperClass : 0);
io.writeInt4(!factory.getIsFiltered(_isInCompilationUnit) ? _isInCompilationUnit : 0);
io.writeInt4(!factory.getIsFiltered(_isInModule) ? _isInModule : 0);
if (_hasSuperInterfaces != null) {
EdgeIterator<TypeExpression> it = getSuperInterfacesIterator();
while (it.hasNext()) {
io.writeInt4(it.next().getId());
}
}
io.writeInt4(0);
if (_hasOthers != null) {
EdgeIterator<Positioned> it = getOthersIterator();
while (it.hasNext()) {
io.writeInt4(it.next().getId());
}
}
io.writeInt4(0);
}
// ---------- Load ----------
@Override
public void load(IO io) {
int _id;
_id = io.readInt4();
if (_id != 0) {
_comments = new EdgeList<Comment>(factory);
while (_id != 0) {
_comments.add(_id);
_id = io.readInt4();
}
}
_id = io.readInt4();
if (_id != 0) {
_hasAnnotations = new EdgeList<Annotation>(factory);
while (_id != 0) {
_hasAnnotations.add(_id);
setParentEdge(_id);
_id = io.readInt4();
}
}
((Range)position).setPathKey(io.readInt4());
((Range)position).setLine(io.readInt4());
((Range)position).setCol(io.readInt4());
((Range)position).setEndLine(io.readInt4());
((Range)position).setEndCol(io.readInt4());
((Range)position).setWideLine(io.readInt4());
((Range)position).setWideCol(io.readInt4());
((Range)position).setWideEndLine(io.readInt4());
((Range)position).setWideEndCol(io.readInt4());
{
byte boolValues = io.readByte1();
isToolGenerated = (boolValues & 1) != 0;
boolValues >>>= 1;
isCompilerGenerated = (boolValues & 1) != 0;
boolValues >>>= 1;
}
name = io.readInt4();
((Range)namePosition).setPathKey(io.readInt4());
((Range)namePosition).setLine(io.readInt4());
((Range)namePosition).setCol(io.readInt4());
((Range)namePosition).setEndLine(io.readInt4());
((Range)namePosition).setEndCol(io.readInt4());
((Range)namePosition).setWideLine(io.readInt4());
((Range)namePosition).setWideCol(io.readInt4());
((Range)namePosition).setWideEndLine(io.readInt4());
((Range)namePosition).setWideEndCol(io.readInt4());
{
byte boolValues = io.readByte1();
isFinal = (boolValues & 1) != 0;
boolValues >>>= 1;
isStatic = (boolValues & 1) != 0;
boolValues >>>= 1;
}
accessibility = AccessibilityKind.values()[io.readUByte1()];
((Range)accessibilityPosition).setPathKey(io.readInt4());
((Range)accessibilityPosition).setLine(io.readInt4());
((Range)accessibilityPosition).setCol(io.readInt4());
((Range)accessibilityPosition).setEndLine(io.readInt4());
((Range)accessibilityPosition).setEndCol(io.readInt4());
((Range)accessibilityPosition).setWideLine(io.readInt4());
((Range)accessibilityPosition).setWideCol(io.readInt4());
((Range)accessibilityPosition).setWideEndLine(io.readInt4());
((Range)accessibilityPosition).setWideEndCol(io.readInt4());
((Range)staticPosition).setPathKey(io.readInt4());
((Range)staticPosition).setLine(io.readInt4());
((Range)staticPosition).setCol(io.readInt4());
((Range)staticPosition).setEndLine(io.readInt4());
((Range)staticPosition).setEndCol(io.readInt4());
((Range)staticPosition).setWideLine(io.readInt4());
((Range)staticPosition).setWideCol(io.readInt4());
((Range)staticPosition).setWideEndLine(io.readInt4());
((Range)staticPosition).setWideEndCol(io.readInt4());
((Range)finalPosition).setPathKey(io.readInt4());
((Range)finalPosition).setLine(io.readInt4());
((Range)finalPosition).setCol(io.readInt4());
((Range)finalPosition).setEndLine(io.readInt4());
((Range)finalPosition).setEndCol(io.readInt4());
((Range)finalPosition).setWideLine(io.readInt4());
((Range)finalPosition).setWideCol(io.readInt4());
((Range)finalPosition).setWideEndLine(io.readInt4());
((Range)finalPosition).setWideEndCol(io.readInt4());
_id = io.readInt4();
if (_id != 0) {
_hasMembers = new EdgeList<Member>(factory);
while (_id != 0) {
_hasMembers.add(_id);
setParentEdge(_id);
_id = io.readInt4();
}
}
{
byte boolValues = io.readByte1();
isStrictfp = (boolValues & 1) != 0;
boolValues >>>= 1;
isAbstract = (boolValues & 1) != 0;
boolValues >>>= 1;
}
lloc = io.readInt4();
((Range)typeNamePosition).setPathKey(io.readInt4());
((Range)typeNamePosition).setLine(io.readInt4());
((Range)typeNamePosition).setCol(io.readInt4());
((Range)typeNamePosition).setEndLine(io.readInt4());
((Range)typeNamePosition).setEndCol(io.readInt4());
((Range)typeNamePosition).setWideLine(io.readInt4());
((Range)typeNamePosition).setWideCol(io.readInt4());
((Range)typeNamePosition).setWideEndLine(io.readInt4());
((Range)typeNamePosition).setWideEndCol(io.readInt4());
((Range)abstractPosition).setPathKey(io.readInt4());
((Range)abstractPosition).setLine(io.readInt4());
((Range)abstractPosition).setCol(io.readInt4());
((Range)abstractPosition).setEndLine(io.readInt4());
((Range)abstractPosition).setEndCol(io.readInt4());
((Range)abstractPosition).setWideLine(io.readInt4());
((Range)abstractPosition).setWideCol(io.readInt4());
((Range)abstractPosition).setWideEndLine(io.readInt4());
((Range)abstractPosition).setWideEndCol(io.readInt4());
((Range)strictfpPosition).setPathKey(io.readInt4());
((Range)strictfpPosition).setLine(io.readInt4());
((Range)strictfpPosition).setCol(io.readInt4());
((Range)strictfpPosition).setEndLine(io.readInt4());
((Range)strictfpPosition).setEndCol(io.readInt4());
((Range)strictfpPosition).setWideLine(io.readInt4());
((Range)strictfpPosition).setWideCol(io.readInt4());
((Range)strictfpPosition).setWideEndLine(io.readInt4());
((Range)strictfpPosition).setWideEndCol(io.readInt4());
binaryName = io.readInt4();
((Range)extendsPosition).setPathKey(io.readInt4());
((Range)extendsPosition).setLine(io.readInt4());
((Range)extendsPosition).setCol(io.readInt4());
((Range)extendsPosition).setEndLine(io.readInt4());
((Range)extendsPosition).setEndCol(io.readInt4());
((Range)extendsPosition).setWideLine(io.readInt4());
((Range)extendsPosition).setWideCol(io.readInt4());
((Range)extendsPosition).setWideEndLine(io.readInt4());
((Range)extendsPosition).setWideEndCol(io.readInt4());
((Range)implementsPosition).setPathKey(io.readInt4());
((Range)implementsPosition).setLine(io.readInt4());
((Range)implementsPosition).setCol(io.readInt4());
((Range)implementsPosition).setEndLine(io.readInt4());
((Range)implementsPosition).setEndCol(io.readInt4());
((Range)implementsPosition).setWideLine(io.readInt4());
((Range)implementsPosition).setWideCol(io.readInt4());
((Range)implementsPosition).setWideEndLine(io.readInt4());
((Range)implementsPosition).setWideEndCol(io.readInt4());
((Range)bodyStartPosition).setPathKey(io.readInt4());
((Range)bodyStartPosition).setLine(io.readInt4());
((Range)bodyStartPosition).setCol(io.readInt4());
((Range)bodyStartPosition).setEndLine(io.readInt4());
((Range)bodyStartPosition).setEndCol(io.readInt4());
((Range)bodyStartPosition).setWideLine(io.readInt4());
((Range)bodyStartPosition).setWideCol(io.readInt4());
((Range)bodyStartPosition).setWideEndLine(io.readInt4());
((Range)bodyStartPosition).setWideEndCol(io.readInt4());
_hasSuperClass = io.readInt4();
if (_hasSuperClass != 0)
setParentEdge(_hasSuperClass);
_isInCompilationUnit = io.readInt4();
_isInModule = io.readInt4();
_id = io.readInt4();
if (_id != 0) {
_hasSuperInterfaces = new EdgeList<TypeExpression>(factory);
while (_id != 0) {
_hasSuperInterfaces.add(_id);
setParentEdge(_id);
_id = io.readInt4();
}
}
_id = io.readInt4();
if (_id != 0) {
_hasOthers = new EdgeList<Positioned>(factory);
while (_id != 0) {
_hasOthers.add(_id);
setParentEdge(_id);
_id = io.readInt4();
}
}
}
}
| 33,050 | 28.562612 | 127 | java |
OpenStaticAnalyzer | OpenStaticAnalyzer-master/java/lib/java/src/main/java/columbus/java/asg/struc/Enum.java | /*
* This file is part of OpenStaticAnalyzer.
*
* Copyright (c) 2004-2018 Department of Software Engineering - University of Szeged
*
* Licensed under Version 1.2 of the EUPL (the "Licence");
*
* You may not use this work except in compliance with the Licence.
*
* You may obtain a copy of the Licence in the LICENSE file or at:
*
* https://joinup.ec.europa.eu/software/page/eupl
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the Licence is distributed on an "AS IS" basis,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the Licence for the specific language governing permissions and
* limitations under the Licence.
*/
package columbus.java.asg.struc;
import columbus.java.asg.*;
/**
* Interface Enum, which represents the {@link columbus.java.asg.struc.Enum Enum} node.
* @columbus.node (missing)
* @columbus.attr semiPosition (Range) : (missing)
*/
public interface Enum extends TypeDeclaration {
/**
* Gives back the {@link columbus.java.asg.struc.Enum#attributeSemiPosition semiPosition} of the node.
* @return Returns with the semiPosition.
*/
public Range getSemiPosition();
/**
* Sets the {@link columbus.java.asg.struc.Enum#attributeSemiPosition semiPosition} of the node.
* @param value The new value of the semiPosition.
*/
public void setSemiPosition(Range value);
}
| 1,416 | 29.804348 | 103 | java |
OpenStaticAnalyzer | OpenStaticAnalyzer-master/java/lib/java/src/main/java/columbus/java/asg/struc/Module.java | /*
* This file is part of OpenStaticAnalyzer.
*
* Copyright (c) 2004-2018 Department of Software Engineering - University of Szeged
*
* Licensed under Version 1.2 of the EUPL (the "Licence");
*
* You may not use this work except in compliance with the Licence.
*
* You may obtain a copy of the Licence in the LICENSE file or at:
*
* https://joinup.ec.europa.eu/software/page/eupl
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the Licence is distributed on an "AS IS" basis,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the Licence for the specific language governing permissions and
* limitations under the Licence.
*/
package columbus.java.asg.struc;
import columbus.java.asg.*;
import columbus.java.asg.base.Named;
/**
* Interface Module, which represents the {@link columbus.java.asg.struc.Module Module} node.
* @columbus.node (missing)
* @columbus.edge packages ({@link columbus.java.asg.struc.Package Package}, multiple) : (missing)
*/
public interface Module extends Named {
/**
* Gives back iterator for the {@link columbus.java.asg.struc.Module#edgePackages packages} edges.
* @return Returns an iterator for the packages edges.
*/
public EdgeIterator<Package> getPackagesIterator();
/**
* Tells whether the node has {@link columbus.java.asg.struc.Module#edgePackages packages} edges or not.
* @return Returns true if the node doesn't have any packages edge.
*/
public boolean getPackagesIsEmpty();
/**
* Gives back how many {@link columbus.java.asg.struc.Module#edgePackages packages} edges the node has.
* @return Returns with the number of packages edges.
*/
public int getPackagesSize();
/**
* Adds a new {@link columbus.java.asg.struc.Module#edgePackages packages} edge to the node.
* @param id The end point of the new packages edge.
*/
public void addPackages(int id);
/**
* Adds a new {@link columbus.java.asg.struc.Module#edgePackages packages} edge to the node.
* @param node The end point of the new packages edge.
*/
public void addPackages(Package node);
}
| 2,144 | 32 | 105 | java |
OpenStaticAnalyzer | OpenStaticAnalyzer-master/java/lib/java/src/main/java/columbus/java/asg/struc/PackageDeclaration.java | /*
* This file is part of OpenStaticAnalyzer.
*
* Copyright (c) 2004-2018 Department of Software Engineering - University of Szeged
*
* Licensed under Version 1.2 of the EUPL (the "Licence");
*
* You may not use this work except in compliance with the Licence.
*
* You may obtain a copy of the Licence in the LICENSE file or at:
*
* https://joinup.ec.europa.eu/software/page/eupl
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the Licence is distributed on an "AS IS" basis,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the Licence for the specific language governing permissions and
* limitations under the Licence.
*/
package columbus.java.asg.struc;
import columbus.java.asg.expr.Expression;
import columbus.java.asg.base.Positioned;
/**
* Interface PackageDeclaration, which represents the {@link columbus.java.asg.struc.PackageDeclaration PackageDeclaration} node.
* @columbus.node (missing)
* @columbus.edge hasPackageName ({@link columbus.java.asg.expr.Expression Expression}, single) : (missing)
* @columbus.edge refersTo ({@link columbus.java.asg.struc.Package Package}, single) : (missing)
*/
public interface PackageDeclaration extends Positioned {
/**
* Gives back the reference of the node the {@link columbus.java.asg.struc.PackageDeclaration#edgeHasPackageName hasPackageName} edge points to.
* @return Returns the end point of the hasPackageName edge.
*/
public Expression getPackageName();
/**
* Sets the {@link columbus.java.asg.struc.PackageDeclaration#edgeHasPackageName hasPackageName} edge.
* @param id The new end point of the hasPackageName edge.
*/
public void setPackageName(int id);
/**
* Sets the {@link columbus.java.asg.struc.PackageDeclaration#edgeHasPackageName hasPackageName} edge.
* @param node The new end point of the hasPackageName edge.
*/
public void setPackageName(Expression node);
/**
* Gives back the reference of the node the {@link columbus.java.asg.struc.PackageDeclaration#edgeRefersTo refersTo} edge points to.
* @return Returns the end point of the refersTo edge.
*/
public Package getRefersTo();
/**
* Sets the {@link columbus.java.asg.struc.PackageDeclaration#edgeRefersTo refersTo} edge.
* @param id The new end point of the refersTo edge.
*/
public void setRefersTo(int id);
/**
* Sets the {@link columbus.java.asg.struc.PackageDeclaration#edgeRefersTo refersTo} edge.
* @param node The new end point of the refersTo edge.
*/
public void setRefersTo(Package node);
}
| 2,595 | 35.055556 | 145 | java |
OpenStaticAnalyzer | OpenStaticAnalyzer-master/java/lib/java/src/main/java/columbus/java/asg/struc/MethodDeclaration.java | /*
* This file is part of OpenStaticAnalyzer.
*
* Copyright (c) 2004-2018 Department of Software Engineering - University of Szeged
*
* Licensed under Version 1.2 of the EUPL (the "Licence");
*
* You may not use this work except in compliance with the Licence.
*
* You may obtain a copy of the Licence in the LICENSE file or at:
*
* https://joinup.ec.europa.eu/software/page/eupl
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the Licence is distributed on an "AS IS" basis,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the Licence for the specific language governing permissions and
* limitations under the Licence.
*/
package columbus.java.asg.struc;
import columbus.java.asg.*;
import columbus.java.asg.expr.TypeExpression;
import columbus.java.asg.type.MethodType;
/**
* Interface MethodDeclaration, which represents the {@link columbus.java.asg.struc.MethodDeclaration MethodDeclaration} node.
* @columbus.node (missing)
* @columbus.attr lloc (int) : (missing)
* @columbus.attr isAbstract (boolean) : (missing)
* @columbus.attr abstractPosition (Range) : (missing)
* @columbus.attr isStrictfp (boolean) : (missing)
* @columbus.attr strictfpPosition (Range) : (missing)
* @columbus.attr parametersStartPosition (Range) : (missing)
* @columbus.attr parametersEndPosition (Range) : (missing)
* @columbus.edge hasReturnType ({@link columbus.java.asg.expr.TypeExpression TypeExpression}, single) : (missing)
* @columbus.edge methodType ({@link columbus.java.asg.type.MethodType MethodType}, single) : (missing)
* @columbus.edge overrides ({@link columbus.java.asg.struc.MethodDeclaration MethodDeclaration}, multiple) : (missing)
*/
public interface MethodDeclaration extends NamedDeclaration {
/**
* Gives back the {@link columbus.java.asg.struc.MethodDeclaration#attributeLloc lloc} of the node.
* @return Returns with the lloc.
*/
public int getLloc();
/**
* Sets the {@link columbus.java.asg.struc.MethodDeclaration#attributeLloc lloc} of the node.
* @param value The new value of the lloc.
*/
public void setLloc(int value);
/**
* Gives back the {@link columbus.java.asg.struc.MethodDeclaration#attributeIsAbstract isAbstract} of the node.
* @return Returns with the isAbstract.
*/
public boolean getIsAbstract();
/**
* Sets the {@link columbus.java.asg.struc.MethodDeclaration#attributeIsAbstract isAbstract} of the node.
* @param value The new value of the isAbstract.
*/
public void setIsAbstract(boolean value);
/**
* Gives back the {@link columbus.java.asg.struc.MethodDeclaration#attributeAbstractPosition abstractPosition} of the node.
* @return Returns with the abstractPosition.
*/
public Range getAbstractPosition();
/**
* Sets the {@link columbus.java.asg.struc.MethodDeclaration#attributeAbstractPosition abstractPosition} of the node.
* @param value The new value of the abstractPosition.
*/
public void setAbstractPosition(Range value);
/**
* Gives back the {@link columbus.java.asg.struc.MethodDeclaration#attributeIsStrictfp isStrictfp} of the node.
* @return Returns with the isStrictfp.
*/
public boolean getIsStrictfp();
/**
* Sets the {@link columbus.java.asg.struc.MethodDeclaration#attributeIsStrictfp isStrictfp} of the node.
* @param value The new value of the isStrictfp.
*/
public void setIsStrictfp(boolean value);
/**
* Gives back the {@link columbus.java.asg.struc.MethodDeclaration#attributeStrictfpPosition strictfpPosition} of the node.
* @return Returns with the strictfpPosition.
*/
public Range getStrictfpPosition();
/**
* Sets the {@link columbus.java.asg.struc.MethodDeclaration#attributeStrictfpPosition strictfpPosition} of the node.
* @param value The new value of the strictfpPosition.
*/
public void setStrictfpPosition(Range value);
/**
* Gives back the {@link columbus.java.asg.struc.MethodDeclaration#attributeParametersStartPosition parametersStartPosition} of the node.
* @return Returns with the parametersStartPosition.
*/
public Range getParametersStartPosition();
/**
* Sets the {@link columbus.java.asg.struc.MethodDeclaration#attributeParametersStartPosition parametersStartPosition} of the node.
* @param value The new value of the parametersStartPosition.
*/
public void setParametersStartPosition(Range value);
/**
* Gives back the {@link columbus.java.asg.struc.MethodDeclaration#attributeParametersEndPosition parametersEndPosition} of the node.
* @return Returns with the parametersEndPosition.
*/
public Range getParametersEndPosition();
/**
* Sets the {@link columbus.java.asg.struc.MethodDeclaration#attributeParametersEndPosition parametersEndPosition} of the node.
* @param value The new value of the parametersEndPosition.
*/
public void setParametersEndPosition(Range value);
/**
* Gives back the reference of the node the {@link columbus.java.asg.struc.MethodDeclaration#edgeHasReturnType hasReturnType} edge points to.
* @return Returns the end point of the hasReturnType edge.
*/
public TypeExpression getReturnType();
/**
* Sets the {@link columbus.java.asg.struc.MethodDeclaration#edgeHasReturnType hasReturnType} edge.
* @param id The new end point of the hasReturnType edge.
*/
public void setReturnType(int id);
/**
* Sets the {@link columbus.java.asg.struc.MethodDeclaration#edgeHasReturnType hasReturnType} edge.
* @param node The new end point of the hasReturnType edge.
*/
public void setReturnType(TypeExpression node);
/**
* Gives back the reference of the node the {@link columbus.java.asg.struc.MethodDeclaration#edgeMethodType methodType} edge points to.
* @return Returns the end point of the methodType edge.
*/
public MethodType getMethodType();
/**
* Sets the {@link columbus.java.asg.struc.MethodDeclaration#edgeMethodType methodType} edge.
* @param id The new end point of the methodType edge.
*/
public void setMethodType(int id);
/**
* Sets the {@link columbus.java.asg.struc.MethodDeclaration#edgeMethodType methodType} edge.
* @param node The new end point of the methodType edge.
*/
public void setMethodType(MethodType node);
/**
* Gives back iterator for the {@link columbus.java.asg.struc.MethodDeclaration#edgeOverrides overrides} edges.
* @return Returns an iterator for the overrides edges.
*/
public EdgeIterator<MethodDeclaration> getOverridesIterator();
/**
* Tells whether the node has {@link columbus.java.asg.struc.MethodDeclaration#edgeOverrides overrides} edges or not.
* @return Returns true if the node doesn't have any overrides edge.
*/
public boolean getOverridesIsEmpty();
/**
* Gives back how many {@link columbus.java.asg.struc.MethodDeclaration#edgeOverrides overrides} edges the node has.
* @return Returns with the number of overrides edges.
*/
public int getOverridesSize();
/**
* Adds a new {@link columbus.java.asg.struc.MethodDeclaration#edgeOverrides overrides} edge to the node.
* @param id The end point of the new overrides edge.
*/
public void addOverrides(int id);
/**
* Adds a new {@link columbus.java.asg.struc.MethodDeclaration#edgeOverrides overrides} edge to the node.
* @param node The end point of the new overrides edge.
*/
public void addOverrides(MethodDeclaration node);
}
| 7,372 | 36.810256 | 142 | java |
mapc2020-lfc | mapc2020-lfc-master/src/env/actions/getAgentNumber.java | package actions;
import jason.asSemantics.DefaultInternalAction;
import jason.asSemantics.TransitionSystem;
import jason.asSemantics.Unifier;
import jason.asSyntax.NumberTermImpl;
import jason.asSyntax.Term;
public class getAgentNumber extends DefaultInternalAction {
private static final long serialVersionUID = 1L;
@Override
@SuppressWarnings("deprecation")
public Object execute(TransitionSystem ts, Unifier un, Term[] args) throws Exception {
String agent = args[0].toString();
un.unifies(args[1], new NumberTermImpl(agent.substring(7)));
return true;
}
}
| 576 | 26.47619 | 87 | java |
mapc2020-lfc | mapc2020-lfc-master/src/env/env/TeamArtifact.java | package env;
import java.awt.Point;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.List;
import java.util.ArrayList;
import java.util.logging.Logger;
import cartago.Artifact;
import cartago.OPERATION;
import cartago.OpFeedbackParam;
import jason.asSyntax.ASSyntax;
import jason.asSyntax.Literal;
import jason.asSyntax.NumberTerm;
import jason.asSyntax.NumberTermImpl;
import jason.util.Pair;
import jason.asSyntax.Atom;
public class TeamArtifact extends Artifact {
private static Logger logger = Logger.getLogger(TeamArtifact.class.getName());
private static Map<String, String> agentNames = new HashMap<String, String>();
private static Map<Integer, Set<String>> actionsByStep = new HashMap<Integer, Set<String>>();
private Map<String, Set<Point>> map1 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map2 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map3 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map4 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map5 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map6 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map7 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map8 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map9 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map10 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map11 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map12 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map13 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map14 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map15 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map16 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map17 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map18 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map19 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map20 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map21 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map22 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map23 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map24 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map25 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map26 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map27 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map28 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map29 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map30 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map31 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map32 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map33 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map34 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map35 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map36 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map37 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map38 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map39 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map40 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map41 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map42 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map43 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map44 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map45 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map46 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map47 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map48 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map49 = new HashMap<String, Set<Point>>();
private Map<String, Set<Point>> map50 = new HashMap<String, Set<Point>>();
private Map<String, Map<String, Set<Point>>> agentmaps = new HashMap<String, Map<String, Set<Point>>>();
private int maxPlanners = 50;
private int planners;
// private int retrievers;
//private int bullys;
private String firstToStop;
private String cartographerY1;
private String cartographerY2;
private String cartographerX1;
private String cartographerX2;
private int sizeX;
private int sizeY;
private int maxTeams;
private int activeTeam;
private int teamsComplete;
private String teamLeader;
// private String goalAgent;
// private Integer targetTaskX;
// private Integer targetTaskY;
// private Integer targetGoalX;
// private Integer targetGoalY;
// private Integer targetTaskX2;
// private Integer targetTaskY2;
// private Integer targetGoalX2;
// private Integer targetGoalY2;
private List<Point> retrieversAvailablePositions = new ArrayList<>();
// private List<Point> uselessAvailablePositions = new ArrayList<>();
private Map<String, Team> teams = new HashMap<String, Team>();
void init(){
logger.info("Team Artifact has been created!");
agentmaps.put("agent1",map1);
agentmaps.put("agent2",map2);
agentmaps.put("agent3",map3);
agentmaps.put("agent4",map4);
agentmaps.put("agent5",map5);
agentmaps.put("agent6",map6);
agentmaps.put("agent7",map7);
agentmaps.put("agent8",map8);
agentmaps.put("agent9",map9);
agentmaps.put("agent10",map10);
agentmaps.put("agent11",map11);
agentmaps.put("agent12",map12);
agentmaps.put("agent13",map13);
agentmaps.put("agent14",map14);
agentmaps.put("agent15",map15);
agentmaps.put("agent16",map16);
agentmaps.put("agent17",map17);
agentmaps.put("agent18",map18);
agentmaps.put("agent19",map19);
agentmaps.put("agent20",map20);
agentmaps.put("agent21",map21);
agentmaps.put("agent22",map22);
agentmaps.put("agent23",map23);
agentmaps.put("agent24",map24);
agentmaps.put("agent25",map25);
agentmaps.put("agent26",map26);
agentmaps.put("agent27",map27);
agentmaps.put("agent28",map28);
agentmaps.put("agent29",map29);
agentmaps.put("agent30",map30);
agentmaps.put("agent31",map31);
agentmaps.put("agent32",map32);
agentmaps.put("agent33",map33);
agentmaps.put("agent34",map34);
agentmaps.put("agent35",map35);
agentmaps.put("agent36",map36);
agentmaps.put("agent37",map37);
agentmaps.put("agent38",map38);
agentmaps.put("agent39",map39);
agentmaps.put("agent40",map40);
agentmaps.put("agent41",map41);
agentmaps.put("agent42",map42);
agentmaps.put("agent43",map43);
agentmaps.put("agent44",map44);
agentmaps.put("agent45",map45);
agentmaps.put("agent46",map46);
agentmaps.put("agent47",map47);
agentmaps.put("agent48",map48);
agentmaps.put("agent49",map49);
agentmaps.put("agent50",map50);
planners = 0;
firstToStop = null;
cartographerY1 = null;
cartographerY2 = null;
cartographerX1 = null;
cartographerX2 = null;
teamLeader = null;
// goalAgent = null;
// targetTaskX = null;
// targetTaskY = null;
// targetGoalX = null;
// targetGoalY = null;
// targetTaskX2 = null;
// targetTaskY2 = null;
// targetGoalX2 = null;
// targetGoalY2 = null;
// deliverer2 = -1;
sizeX = 0;
sizeY = 0;
// retrievers = 10;
teamsComplete = 0;
activeTeam = 15;
//bullys = 1;
}
@OPERATION
void firstToStop(String agent, OpFeedbackParam<Boolean> flag){
if(this.firstToStop != null) {
flag.set(false);
}
else {
this.firstToStop = agent;
this.teamLeader = agent;
flag.set(true);
logger.info("!!!! First to stop "+firstToStop);
}
}
@OPERATION
void addCartographer(String agent1, String agent2, OpFeedbackParam<Integer> flag){
if(this.cartographerY1 == null) {
flag.set(1);
this.cartographerY1 = agent1;
this.cartographerY2 = agent2;
logger.info("!!!! Cartographers Y "+cartographerY1+" and "+cartographerY2);
}
else if (this.cartographerX1 == null && this.cartographerY1 != agent1 && this.cartographerY1 != agent2 && this.cartographerY2 != agent1 && this.cartographerY2 != agent2) {
flag.set(2);
this.cartographerX1 = agent1;
this.cartographerX2 = agent2;
logger.info("!!!! Cartographers X "+cartographerX1+" and "+cartographerX2);
}
else {
flag.set(0);
}
}
@OPERATION
void callPlanner(OpFeedbackParam<Boolean> flag){
// logger.info("Calling planner with planners "+this.planners);
if(this.planners+1 <= this.maxPlanners) {
this.planners++;
flag.set(true);
}
else {
flag.set(false);
}
}
@OPERATION
void plannerDone(){
this.planners--;
// logger.info("Planner done, decreasing planners "+this.planners);
}
@OPERATION
void joinStopGroup(OpFeedbackParam<String> flag, OpFeedbackParam<String> teamLead){
if (this.teamsComplete != this.maxTeams) {
// if (this.goalAgent2 == null) {
// flag.set("origin2");
// this.goalAgent2 = this.getCurrentOpAgentId().getAgentName();
// }
if (this.activeTeam == 15) {
logger.info("NEW DELIVERER "+getCurrentOpAgentId().getAgentName());
this.activeTeam = activeTeam - 2;
flag.set("deliverer");
teamLead.set(this.teamLeader);
}
else if (this.activeTeam > 1) {
this.activeTeam--;
flag.set("retriever");
teamLead.set(this.teamLeader);
}
else if (this.activeTeam == 1) {
this.activeTeam--;
flag.set("bully");
this.teamsComplete++;
teamLead.set(this.teamLeader);
}
else {
this.activeTeam = 15;
this.teamLeader = getCurrentOpAgentId().getAgentName();
flag.set("origin");
logger.info("NEW TEAM LEADER "+this.teamLeader);
teamLead.set(this.teamLeader);
}
// else {
// flag.set("useless");
// }
}
else {
flag.set("bully");
teamLead.set(this.teamLeader);
}
}
@OPERATION
void getTargetGoal(String name, OpFeedbackParam<Integer> x, OpFeedbackParam<Integer> y){
x.set(teams.get(name).getTargetGoalX());
y.set(teams.get(name).getTargetGoalY());
}
@OPERATION
void getTargetGoals(OpFeedbackParam<Literal[]> goals){
List<Literal> targetGoals = new ArrayList<Literal>();
for(Entry<String, Team> team : teams.entrySet()) {
Literal literal = ASSyntax.createLiteral("goal");
NumberTerm x = new NumberTermImpl(team.getValue().targetGoalX);
NumberTerm y = new NumberTermImpl(team.getValue().targetGoalY);
literal.addTerm(x);
literal.addTerm(y);
targetGoals.add(literal);
}
Literal[] arrayGoals = targetGoals.toArray(new Literal[targetGoals.size()]);
goals.set(arrayGoals);
}
// @OPERATION
// void getTargetGoal2(OpFeedbackParam<String> name, OpFeedbackParam<Integer> x, OpFeedbackParam<Integer> y){
// name.set(goalAgent2);
// x.set(targetGoalX2);
// y.set(targetGoalY2);
// }
@OPERATION
void getTargetTaskboard(String name, OpFeedbackParam<Integer> x, OpFeedbackParam<Integer> y){
x.set(teams.get(name).getTargetTaskX());
y.set(teams.get(name).getTargetTaskY());
}
// @OPERATION
// void getTargetTaskboard2(OpFeedbackParam<Integer> x, OpFeedbackParam<Integer> y){
// x.set(targetTaskX2);
// y.set(targetTaskY2);
// }
@OPERATION
void setTargets(String name, int taskx, int tasky, int goalx, int goaly){
this.retrieversAvailablePositions.clear();
// this.uselessAvailablePositions.clear();
// for (int i = 0; i < 50; i++) {
// Point p = new Point(goalx-25+i, goaly-10);
// this.uselessAvailablePositions.add(p);
// }
for (int i = goaly - 1; i <= goaly + 5; i = i + 3) { // add west line of the rectangle
Point p = new Point(goalx-9, i);
this.retrieversAvailablePositions.add(p);
// Point p2 = new Point(goalx-11, i);
// this.retrieversAvailablePositions.add(p2);
}
for (int i = goaly - 1; i <= goaly + 5; i = i + 3) { // add east line of the rectangle
Point p = new Point(goalx+9, i);
this.retrieversAvailablePositions.add(p);
// Point p2 = new Point(goalx+11, i);
// this.retrieversAvailablePositions.add(p2);
}
for (int i = goalx - 9; i <= goalx + 9; i = i + 3) { // add north line of the rectangle
Point p = new Point(i, goaly-4);
this.retrieversAvailablePositions.add(p);
// Point p2 = new Point(i, goaly-6);
// this.retrieversAvailablePositions.add(p2);
}
for (int i = goalx - 9; i <= goalx + 9; i = i + 3) { // add south line of the rectangle
Point p = new Point(i, goaly+8);
this.retrieversAvailablePositions.add(p);
// Point p2 = new Point(i, goaly+10);
// this.retrieversAvailablePositions.add(p2);
}
// logger.info("Size of retriever positions: "+this.retrieversAvailablePositions.toArray().length);
// for(Point p: this.retrieversAvailablePositions) {
// logger.info("@@@@ position("+p.x+","+p.y+")");
// }
Team team = new Team(taskx, tasky, goalx, goaly, retrieversAvailablePositions);
teams.put(name, team);
this.retrieversAvailablePositions.clear();
}
// @OPERATION
// void setTargets(String name, int taskx, int tasky, int goalx, int goaly, int taskx2, int tasky2, int goalx2, int goaly2){
// this.goalAgent = name;
// this.targetTaskX = taskx;
// this.targetTaskY = tasky;
// this.targetGoalX = goalx;
// this.targetGoalY = goaly;
// this.targetTaskX2 = taskx2;
// this.targetTaskY2 = tasky2;
// this.targetGoalX2 = goalx2;
// this.targetGoalY2 = goaly2;
// this.retrieversAvailablePositions.clear();
// for (int i = goaly - 1; i <= goaly + 5; i = i + 3) { // add west line of the rectangle
// Point p = new Point(goalx-9, i);
// this.retrieversAvailablePositions.add(p);
//// Point p2 = new Point(goalx-11, i);
//// this.retrieversAvailablePositions.add(p2);
// }
// for (int i = goaly - 1; i <= goaly + 5; i = i + 3) { // add east line of the rectangle
// Point p = new Point(goalx+9, i);
// this.retrieversAvailablePositions.add(p);
//// Point p2 = new Point(goalx+11, i);
//// this.retrieversAvailablePositions.add(p2);
// }
// for (int i = goalx - 9; i <= goalx + 9; i = i + 3) { // add north line of the rectangle
// Point p = new Point(i, goaly-4);
// this.retrieversAvailablePositions.add(p);
//// Point p2 = new Point(i, goaly-6);
//// this.retrieversAvailablePositions.add(p2);
// }
// for (int i = goalx - 9; i <= goalx + 9; i = i + 3) { // add south line of the rectangle
// Point p = new Point(i, goaly+8);
// this.retrieversAvailablePositions.add(p);
//// Point p2 = new Point(i, goaly+10);
//// this.retrieversAvailablePositions.add(p2);
// }
//// logger.info("Size of retriever positions: "+this.retrieversAvailablePositions.toArray().length);
//// for(Point p: this.retrieversAvailablePositions) {
//// logger.info("@@@@ position("+p.x+","+p.y+")");
//// }
// }
@OPERATION
void updateTargets(String name, int x, int y) {
this.retrieversAvailablePositions.clear();
this.retrieversAvailablePositions.addAll(teams.get(name).getRetrieversAvailablePositions());
if (sizeX != 0 && sizeY != 0) {
List<Point> retaux = new ArrayList<>();
if (teams.get(name).getTargetTaskX() + x < 0) {
teams.get(name).setTargetTaskX(((teams.get(name).getTargetTaskX() + x) % sizeX) + sizeX);
} else {
teams.get(name).setTargetTaskX((teams.get(name).getTargetGoalX() + x) % sizeX);
}
if (teams.get(name).getTargetTaskY() + y < 0) {
teams.get(name).setTargetTaskY(((teams.get(name).getTargetTaskY() + y) % sizeY) + sizeY);
} else {
teams.get(name).setTargetTaskY((teams.get(name).getTargetTaskY() + y) % sizeY);
}
if (teams.get(name).getTargetGoalX() + x < 0) {
teams.get(name).setTargetGoalX(((teams.get(name).getTargetGoalX() + x) % sizeX) + sizeX);
} else {
teams.get(name).setTargetGoalX((teams.get(name).getTargetGoalX() + x) % sizeX);
}
if (teams.get(name).getTargetGoalY() + y < 0) {
teams.get(name).setTargetGoalY(((teams.get(name).getTargetGoalY() + y) % sizeY) + sizeY);
} else {
teams.get(name).setTargetGoalY((teams.get(name).getTargetGoalY() + y) % sizeY);
}
for(Point p: this.retrieversAvailablePositions) {
Point pnew = new Point(0, 0);
if (p.x + x < 0) {
pnew.x = ((p.x + x) % sizeX) + sizeX;
} else {
pnew.x = (p.x + x) % sizeX;
}
if (p.y + y < 0) {
pnew.y = ((p.y + y) % sizeY) + sizeY;
} else {
pnew.y = (p.y + y) % sizeY;
}
retaux.add(pnew);
}
retrieversAvailablePositions.clear();
retrieversAvailablePositions.addAll(retaux);
// for(Point p: this.uselessAvailablePositions) {
// Point pnew = new Point(0, 0);
// if (p.x + x < 0) {
// pnew.x = ((p.x + x) % sizeX) + sizeX;
// } else {
// pnew.x = (p.x + x) % sizeX;
// }
// if (p.y + y < 0) {
// pnew.y = ((p.y + y) % sizeY) + sizeY;
// } else {
// pnew.y = (p.y + y) % sizeY;
// }
// retaux.add(pnew);
// }
// uselessAvailablePositions.clear();
// uselessAvailablePositions.addAll(retaux);
}
else if (sizeX != 0) {
List<Point> retaux = new ArrayList<>();
if (teams.get(name).getTargetTaskX() + x < 0) {
teams.get(name).setTargetTaskX(((teams.get(name).getTargetTaskX() + x) % sizeX) + sizeX);
} else {
teams.get(name).setTargetTaskX((teams.get(name).getTargetTaskX() + x) % sizeX);
}
teams.get(name).setTargetTaskY(teams.get(name).getTargetTaskY() + y);
if (teams.get(name).getTargetGoalX() + x < 0) {
teams.get(name).setTargetGoalX(((teams.get(name).getTargetGoalX() + x) % sizeX) + sizeX);
} else {
teams.get(name).setTargetGoalX((teams.get(name).getTargetGoalX() + x) % sizeX);
}
teams.get(name).setTargetGoalY(teams.get(name).getTargetGoalY() + y);
for(Point p: this.retrieversAvailablePositions) {
Point pnew = new Point(0, 0);
if (p.x + x < 0) {
pnew.x = ((p.x + x) % sizeX) + sizeX;
} else {
pnew.x = (p.x + x) % sizeX;
}
pnew.y += y;
retaux.add(pnew);
}
retrieversAvailablePositions.clear();
retrieversAvailablePositions.addAll(retaux);
// for(Point p: this.uselessAvailablePositions) {
// Point pnew = new Point(0, 0);
// if (p.x + x < 0) {
// pnew.x = ((p.x + x) % sizeX) + sizeX;
// } else {
// pnew.x = (p.x + x) % sizeX;
// }
// pnew.y += y;
// retaux.add(pnew);
// }
// uselessAvailablePositions.clear();
// uselessAvailablePositions.addAll(retaux);
}
else if (sizeY != 0) {
List<Point> retaux = new ArrayList<>();
teams.get(name).setTargetTaskX(teams.get(name).getTargetTaskX() + x);
if (teams.get(name).getTargetTaskY() + y < 0) {
teams.get(name).setTargetTaskY(((teams.get(name).getTargetTaskY() + y) % sizeY) + sizeY);
} else {
teams.get(name).setTargetTaskY((teams.get(name).getTargetTaskY() + y) % sizeY);
}
teams.get(name).setTargetGoalX(teams.get(name).getTargetGoalX() + x);
if (teams.get(name).getTargetGoalY() + y < 0) {
teams.get(name).setTargetGoalY(((teams.get(name).getTargetGoalY() + y) % sizeY) + sizeY);
} else {
teams.get(name).setTargetGoalY((teams.get(name).getTargetGoalY() + y) % sizeY);
}
for(Point p: this.retrieversAvailablePositions) {
Point pnew = new Point(0, 0);
pnew.x += x;
if (p.y + y < 0) {
pnew.y = ((p.y + y) % sizeY) + sizeY;
} else {
pnew.y = (p.y + y) % sizeY;
}
retaux.add(pnew);
}
retrieversAvailablePositions.clear();
retrieversAvailablePositions.addAll(retaux);
// for(Point p: this.uselessAvailablePositions) {
// Point pnew = new Point(0, 0);
// pnew.x += x;
// if (p.y + y < 0) {
// pnew.y = ((p.y + y) % sizeY) + sizeY;
// } else {
// pnew.y = (p.y + y) % sizeY;
// }
// retaux.add(pnew);
// }
// uselessAvailablePositions.clear();
// uselessAvailablePositions.addAll(retaux);
} else {
teams.get(name).setTargetTaskX(teams.get(name).getTargetTaskX() + x);
teams.get(name).setTargetTaskY(teams.get(name).getTargetTaskY() + y);
teams.get(name).setTargetGoalX(teams.get(name).getTargetGoalX() + x);
teams.get(name).setTargetGoalY(teams.get(name).getTargetGoalY() + y);
for(Point p: this.retrieversAvailablePositions) {
p.x += x;
p.y += y;
}
// for(Point p: this.uselessAvailablePositions) {
// p.x += x;
// p.y += y;
// }
}
teams.get(name).setRetrieversAvailablePositions(this.retrieversAvailablePositions);
this.retrieversAvailablePositions.clear();
}
// @OPERATION
// void initRetrieverAvailablePos(String name) {
//// logger.info("initRetrieversAvailablePos");
// if(this.targetGoalX == null | this.targetGoalY == null) return;
// this.retrieversAvailablePositions.clear();
// for(String key : agentmaps.get(name).keySet()) {
// if(key.startsWith("goal_")) {
// for(Point pp : agentmaps.get(name).get(key)) {
// if(targetGoalX == pp.x && targetGoalY == pp.y) {
//// logger.info("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
//// logger.info(((OriginPoint) pp).retrievers+"");
// for(Point retriever : ((OriginPoint) pp).retrievers) {
//// logger.info("[" + name + "]" + "( " + retriever.x + ", " + retriever.y + " ) retriever added");
// this.retrieversAvailablePositions.add(retriever);
// }
// return;
// }
// }
// }
// }
// }
@OPERATION
void getRetrieverAvailablePos(String name, int myX, int myY, OpFeedbackParam<Integer> x, OpFeedbackParam<Integer> y) {
this.retrieversAvailablePositions.clear();
this.retrieversAvailablePositions.addAll(teams.get(name).getRetrieversAvailablePositions());
int toRemove = -1;
double dist = Double.MAX_VALUE;
for(int i = 0; i < this.retrieversAvailablePositions.size(); i++) {
double d = Math.abs(myX - this.retrieversAvailablePositions.get(i).x) + Math.abs(myY - this.retrieversAvailablePositions.get(i).y);
if(d < dist) {
toRemove = i;
dist = d;
}
}
if(toRemove != -1) {
x.set(this.retrieversAvailablePositions.get(toRemove).x);
y.set(this.retrieversAvailablePositions.get(toRemove).y);
this.retrieversAvailablePositions.remove(toRemove);
}
teams.get(name).setRetrieversAvailablePositions(this.retrieversAvailablePositions);
this.retrieversAvailablePositions.clear();
}
// @OPERATION
// void getUselessAvailablePos(int myX, int myY, OpFeedbackParam<Integer> x, OpFeedbackParam<Integer> y) {
// int toRemove = -1;
// double dist = Double.MAX_VALUE;
// for(int i = 0; i < this.uselessAvailablePositions.size(); i++) {
// double d = Math.abs(myX - this.uselessAvailablePositions.get(i).x) + Math.abs(myY - this.uselessAvailablePositions.get(i).y);
// if(d < dist) {
// toRemove = i;
// dist = d;
// }
// }
// if(toRemove != -1) {
// x.set(this.uselessAvailablePositions.get(toRemove).x);
// y.set(this.uselessAvailablePositions.get(toRemove).y);
// this.uselessAvailablePositions.remove(toRemove);
// }
// }
@OPERATION
void addRetrieverAvailablePos(String name, int x, int y) {
// logger.info("(" + x + ", " + y + ") is now a retriever available position");
teams.get(name).addRetrieversAvailablePositions(x, y);
}
@OPERATION
void addTeamSize(int size){
maxTeams = size;
}
@OPERATION
void addServerName(String agent, String agentServer){
agentNames.put(agent,agentServer);
}
@OPERATION
void getServerName(String agent, OpFeedbackParam<String> agentServer){
agentServer.set(agentNames.get(agent));
}
@OPERATION
void setSizeX(int x){
sizeX = x;
}
@OPERATION
void setSizeY(int y){
sizeY = y;
}
@OPERATION
void evaluateOrigin(String name, int x, int y, String evaluation) {
//if(evaluation.equals("boh")) return;
// logger.info("evaluateOrigin(" + name + ", " + x + ", " + y + ", " + evaluation + ")");
for(String key : agentmaps.get(name).keySet()) {
if(key.startsWith("goal_")) {
for(Point pp : agentmaps.get(name).get(key)) {
if(x == pp.x && y == pp.y) {
if(pp instanceof OriginPoint) {
if(((OriginPoint) pp).evaluated.equals("boh")) {
((OriginPoint) pp).evaluated = evaluation;
}
return;
}
agentmaps.get(name).get(key).remove(pp);
agentmaps.get(name).get(key).add(new OriginPoint(x, y, evaluation));
return;
}
}
}
}
// logger.info("not found it");
}
@OPERATION
void evaluateOrigin(String name, int x, int y, String evaluation, int maxPosS, int maxPosW, int maxPosE) {
//if(evaluation.equals("boh")) return;
// logger.info("evaluateOrigin(" + name + ", " + x + ", " + y + ", " + evaluation + ")");
for(String key : agentmaps.get(name).keySet()) {
if(key.startsWith("goal_")) {
for(Point pp : agentmaps.get(name).get(key)) {
if(x == pp.x && y == pp.y) {
if(pp instanceof OriginPoint) {
if(((OriginPoint) pp).evaluated.equals("boh")) {
((OriginPoint) pp).evaluated = evaluation;
((OriginPoint) pp).maxPosS = maxPosS;
((OriginPoint) pp).maxPosW = maxPosW;
((OriginPoint) pp).maxPosE = maxPosE;
}
return;
}
agentmaps.get(name).get(key).remove(pp);
agentmaps.get(name).get(key).add(new OriginPoint(x, y, evaluation, maxPosS, maxPosW, maxPosE));
return;
}
}
}
}
// logger.info("not found it");
}
@OPERATION
void addScoutToOrigin(String name, int originX, int originY, int scoutX, int scoutY) {
for(String key : agentmaps.get(name).keySet()) {
if(key.startsWith("goal_")) {
for(Point pp : agentmaps.get(name).get(key)) {
if(pp instanceof OriginPoint & originX == pp.x && originY == pp.y) {
((OriginPoint) pp).scouts.add(new Point(scoutX, scoutY));
return;
}
}
}
}
}
@OPERATION
void addRetrieverToOrigin(String name, int originX, int originY, int retrieverX, int retrieverY) {
for(String key : agentmaps.get(name).keySet()) {
if(key.startsWith("goal_")) {
for(Point pp : agentmaps.get(name).get(key)) {
if(pp instanceof OriginPoint & originX == pp.x && originY == pp.y) {
// logger.info("[" + name + "]" + "(" + retrieverX + ", " + retrieverY + ") retriever added to cluster " + key);
((OriginPoint) pp).retrievers.add(new Point(retrieverX, retrieverY));
return;
}
}
}
}
// logger.info("[" + name + "]" + "addRetrieverToOrigin has not add anything");
}
@OPERATION
void updateGoalMap(String name, int x, int y, OpFeedbackParam<String> clusterInserterIn, OpFeedbackParam<Boolean> isANewCluster) {
Point p = new Point(x, y);
// logger.info("[" + name + "]: Try to add goal (" + x + ", " + y + ")");
double minDistance = 5;
String myCluster = null;
int id = 0;
for(String key : agentmaps.get(name).keySet()) {
if(key.startsWith("goal_")) {
double distance = 0;
for(Point pp : agentmaps.get(name).get(key)) {
if(p.x == pp.x && p.y == pp.y) {
return;
}
distance += Math.abs(p.x-pp.x) + Math.abs(p.y-pp.y);
//System.out.println("Point (" + p.x + ", " + p.y + ") distance from (" + pp.x + ", " + pp.y + "):" + (Math.abs(p.x-pp.x) + Math.abs(p.y-pp.y)));
}
distance = distance / agentmaps.get(name).get(key).size();
if(distance < minDistance) {
minDistance = distance;
myCluster = key;
}
id++;
}
}
if(myCluster == null) {
//logger.info("ID: " + id);
Set<Point> set = new HashSet<Point>();
//set.add(new OriginPoint(x, y));
set.add(p);
agentmaps.get(name).put("goal_" + id, set);
clusterInserterIn.set("goal_" + id);
isANewCluster.set(true);
//logger.info("[" + name + "]" + " added point (" + p.x + ", " + p.y + ") to cluster " + agentmaps.get(name).get("goal_" + id) + " because distance is: " + minDistance);
} else {
//logger.info("[" + name + "]" + " added point (" + p.x + ", " + p.y + ") to cluster " + agentmaps.get(name).get(myCluster) + " because distance is: " + minDistance);
clusterInserterIn.set(myCluster);
isANewCluster.set(false);
agentmaps.get(name).get(myCluster).add(p);
}
}
@OPERATION
void updateMap(String name, String type, int x, int y) {
Point p = new Point(x, y);
// if(!type.startsWith("goal_")) {
if (!agentmaps.get(name).containsKey(type)) {
Set<Point> set = new HashSet<Point>();
set.add(p);
agentmaps.get(name).put(type, set);
}
else {
agentmaps.get(name).get(type).add(p);
}
// }
}
@OPERATION
void updateLocations(String name, String axis, int size) {
Map<String, Set<Point>> mapaux = new HashMap<String, Set<Point>>();
for (Map.Entry<String, Set<Point>> entry : agentmaps.get(name).entrySet()) {
for (Point p : entry.getValue()) {
int x;
int y;
if (axis.equals("x")) {
if (p.x % size < 0) {
x = p.x % size + size;
} else {
x = p.x % size;
}
y = p.y;
} else {
x = p.x;
if (p.y % size < 0) {
y = p.y % size + size;
} else {
y = p.y % size;
}
}
Point pnew = new Point(x, y);
if (!mapaux.containsKey(entry.getKey())) {
Set<Point> set = new HashSet<Point>();
set.add(pnew);
mapaux.put(entry.getKey(), set);
}
else {
mapaux.get(entry.getKey()).add(pnew);
}
}
}
agentmaps.get(name).clear();
agentmaps.get(name).putAll(mapaux);
}
private static class OriginPoint extends Point{
private String evaluated = "boh";
private List<Point> scouts = new ArrayList<>();
private List<Point> retrievers = new ArrayList<>();
private int maxPosS;
private int maxPosW;
private int maxPosE;
public OriginPoint(int x, int y, String evaluated) {
super(x, y);
this.evaluated = evaluated;
}
public OriginPoint(int x, int y, String evaluated, int maxPosS, int maxPosW, int maxPosE) {
super(x, y);
this.evaluated = evaluated;
this.maxPosS = maxPosS;
this.maxPosW = maxPosW;
this.maxPosE = maxPosE;
}
// nothing different to add for now
}
@OPERATION
void getAllSize(String name, OpFeedbackParam<Integer> size){
size.set(agentmaps.get(name).values().stream().mapToInt(Set::size).sum());
}
@OPERATION
void getDispensers(String name, OpFeedbackParam<Literal[]> dispensers){
List<Literal> things = new ArrayList<Literal>();
for (Map.Entry<String, Set<Point>> entry : agentmaps.get(name).entrySet()) {
if (!entry.getKey().startsWith("goal") && !entry.getKey().startsWith("taskboard")) {
// logger.info(name+" : "+entry.getKey() + " = " + entry.getValue());
Atom type = new Atom(entry.getKey());
for (Point p : entry.getValue()) {
Literal literal = ASSyntax.createLiteral("dispenser");
NumberTerm x = new NumberTermImpl(p.x);
NumberTerm y = new NumberTermImpl(p.y);
literal.addTerm(type);
literal.addTerm(x);
literal.addTerm(y);
things.add(literal);
}
}
}
Literal[] arraythings = things.toArray(new Literal[things.size()]);
dispensers.set(arraythings);
}
@OPERATION
void getTaskboards(String name, OpFeedbackParam<Literal[]> taskboards){
List<Literal> things = new ArrayList<Literal>();
for (Map.Entry<String, Set<Point>> entry : agentmaps.get(name).entrySet()) {
if (entry.getKey().startsWith("taskboard")) {
for (Point p : entry.getValue()) {
Literal literal = ASSyntax.createLiteral("taskboard");
NumberTerm x = new NumberTermImpl(p.x);
NumberTerm y = new NumberTermImpl(p.y);
literal.addTerm(x);
literal.addTerm(y);
things.add(literal);
}
}
}
Literal[] arraythings = things.toArray(new Literal[things.size()]);
taskboards.set(arraythings);
}
@OPERATION
void getGoals(String name, OpFeedbackParam<Literal[]> goals){
List<Literal> things = new ArrayList<Literal>();
for (Map.Entry<String, Set<Point>> entry : agentmaps.get(name).entrySet()) {
if (entry.getKey().startsWith("goal")) {
for (Point p : entry.getValue()) {
Literal literal = ASSyntax.createLiteral("goal");
NumberTerm x = new NumberTermImpl(p.x);
NumberTerm y = new NumberTermImpl(p.y);
literal.addTerm(x);
literal.addTerm(y);
things.add(literal);
}
}
}
Literal[] arraythings = things.toArray(new Literal[things.size()]);
goals.set(arraythings);
}
@OPERATION
void getGoalClusters(String name, OpFeedbackParam<Literal[]> clusters){
List<Literal> things = new ArrayList<Literal>();
for (Map.Entry<String, Set<Point>> entry : agentmaps.get(name).entrySet()) {
if (entry.getKey().startsWith("goal_")) {
// logger.info(name+" : "+entry.getKey() + " = " + entry.getValue());
Literal cluster = ASSyntax.createLiteral("cluster");
cluster.addTerm(ASSyntax.createAtom(entry.getKey()));
List<Literal> goals = new ArrayList<Literal>();
for (Point p : entry.getValue()) {
Literal literal = null;
if(p instanceof OriginPoint) {
literal = ASSyntax.createLiteral("origin");
literal.addTerm(new Atom(((OriginPoint) p).evaluated));
} else {
literal = ASSyntax.createLiteral("goal");
}
NumberTerm x = new NumberTermImpl(p.x);
NumberTerm y = new NumberTermImpl(p.y);
literal.addTerm(x);
literal.addTerm(y);
goals.add(literal);
}
cluster.addTerm(ASSyntax.createList(goals.toArray(new Literal[goals.size()])));
things.add(cluster);
}
}
Literal[] arraythings = things.toArray(new Literal[things.size()]);
clusters.set(arraythings);
}
@OPERATION
void getGoalClustersWithScouts(String name, OpFeedbackParam<Literal[]> clusters){
List<Literal> things = new ArrayList<Literal>();
for (Map.Entry<String, Set<Point>> entry : agentmaps.get(name).entrySet()) {
if (entry.getKey().startsWith("goal_")) {
// logger.info(name+" : "+entry.getKey() + " = " + entry.getValue());
Literal cluster = ASSyntax.createLiteral("cluster");
cluster.addTerm(ASSyntax.createAtom(entry.getKey()));
List<Literal> goals = new ArrayList<Literal>();
for (Point p : entry.getValue()) {
Literal literal = null;
if(p instanceof OriginPoint) {
literal = ASSyntax.createLiteral("origin");
literal.addTerm(new Atom(((OriginPoint) p).evaluated));
List<Literal> scouts = new ArrayList<Literal>();
for(Point scout : ((OriginPoint)p).scouts) {
Literal s = ASSyntax.createLiteral("scout");
s.addTerm(new NumberTermImpl(scout.x));
s.addTerm(new NumberTermImpl(scout.y));
scouts.add(s);
}
List<Literal> retrievers = new ArrayList<Literal>();
for(Point retriever : ((OriginPoint)p).retrievers) {
Literal s = ASSyntax.createLiteral("retriever");
s.addTerm(new NumberTermImpl(retriever.x));
s.addTerm(new NumberTermImpl(retriever.y));
retrievers.add(s);
}
literal.addTerm(ASSyntax.createList(scouts.toArray(new Literal[scouts.size()])));
literal.addTerm(ASSyntax.createList(retrievers.toArray(new Literal[retrievers.size()])));
literal.addTerm(new NumberTermImpl(((OriginPoint)p).maxPosS));
literal.addTerm(new NumberTermImpl(((OriginPoint)p).maxPosW));
literal.addTerm(new NumberTermImpl(((OriginPoint)p).maxPosE));
} else {
literal = ASSyntax.createLiteral("goal");
}
NumberTerm x = new NumberTermImpl(p.x);
NumberTerm y = new NumberTermImpl(p.y);
literal.addTerm(x);
literal.addTerm(y);
goals.add(literal);
}
cluster.addTerm(ASSyntax.createList(goals.toArray(new Literal[goals.size()])));
things.add(cluster);
}
}
Literal[] arraythings = things.toArray(new Literal[things.size()]);
clusters.set(arraythings);
}
// @OPERATION
// void getGoals(String name, String cluster, OpFeedbackParam<Literal[]> goals){
// List<Literal> things = new ArrayList<Literal>();
// for(Point p : agentmaps.get(name).get(cluster)) {
// Literal literal = null;
// if(p instanceof OriginPoint) {
// literal = ASSyntax.createLiteral("origin");
// literal.addTerm(new Atom(((OriginPoint) p).evaluated));
// } else {
// literal = ASSyntax.createLiteral("goal");
// }
// NumberTerm x = new NumberTermImpl(p.x);
// NumberTerm y = new NumberTermImpl(p.y);
// literal.addTerm(x);
// literal.addTerm(y);
// things.add(literal);
// }
// Literal[] arraythings = things.toArray(new Literal[things.size()]);
// goals.set(arraythings);
// }
@OPERATION
void addAvailableAgent(String leader, String name, String type) {
teams.get(leader).addAgentAvailable(name, type);
}
@OPERATION
void removeAvailableAgent(String leader, String name) {
teams.get(leader).removeAgentAvailable(name);
}
@OPERATION
void getAvailableAgent(String leader, OpFeedbackParam<Literal[]> list){
List<Literal> agents = new ArrayList<Literal>();
for (Map.Entry<String, String> entry :teams.get(leader).getAgentAvailable().entrySet()) {
Literal literal = ASSyntax.createLiteral("agent");
Atom name = new Atom(entry.getKey());
Atom type = new Atom(entry.getValue());
literal.addTerm(name);
literal.addTerm(type);
agents.add(literal);
}
Literal[] arrayagents = agents.toArray(new Literal[agents.size()]);
list.set(arrayagents);
}
@OPERATION
void getAvailableMeType(String leader, String me, OpFeedbackParam<String> type) {
type.set(teams.get(leader).getAgentAvailableType(me));
}
@OPERATION
void getBlocks(String name, OpFeedbackParam<Literal[]> list) {
List<Literal> things = new ArrayList<Literal>();
for(Pair<String, String> p : teams.get(name).getTheBlocks()) {
Literal literal = ASSyntax.createLiteral("block");
literal.addTerm(ASSyntax.createAtom(p.getFirst()));
literal.addTerm(ASSyntax.createAtom(p.getSecond()));
things.add(literal);
}
Literal[] arraythings = things.toArray(new Literal[things.size()]);
list.set(arraythings);
}
@OPERATION
void addBlock(String leader, String ag, String b) {
teams.get(leader).addBlock(ag, b);
}
@OPERATION
void removeBlock(String leader, String ag) {
teams.get(leader).removeBlock(ag);
}
@OPERATION
void clearTeam() {
agentNames.clear();
actionsByStep.clear();
agentmaps.clear();
map1.clear();
map2.clear();
map3.clear();
map4.clear();
map5.clear();
map6.clear();
map7.clear();
map8.clear();
map9.clear();
map10.clear();
retrieversAvailablePositions.clear();
teams.clear();
this.init();
}
@OPERATION
void chosenAction(int step) {
String agent = getCurrentOpAgentId().getAgentName();
Set<String> agents = actionsByStep.remove(step);
if (agents == null)
agents = new HashSet<String>();
if (!agents.contains(agent)) {
agents.add(agent);
actionsByStep.put(step, agents);
if (this.getObsPropertyByTemplate("chosenActions", step,null) != null)
this.removeObsPropertyByTemplate("chosenActions", step, null);
this.defineObsProperty("chosenActions", step, agents.toArray());
// clean belief
if (actionsByStep.containsKey(step-3)) {
actionsByStep.remove(step-3);
this.removeObsPropertyByTemplate("chosenActions", step-3, null);
}
}
}
/*
* The following methods are for deciding where to send the explorer
* agent if we do not have enough knowledge about goal positions
*
* NOTE: all the following methods assume that the size of the map is known.
*/
/*
* Input: GLOBAL coordinate of the source and GLOBAL coordinate of the target
*
* Output: returns the minimum Manhattan distance between source and target while
* assuming that we can go over the edge of the map
*
*/
private int getMinimalDistanceFromTarget(Point sourceCoordinates, Point targetCoordinates) {
int maxX = this.sizeX / 2;
int maxY = this.sizeY / 2;
int tmpX = Math.abs((int)targetCoordinates.getX() - (int)sourceCoordinates.getX());
int finalX = tmpX;
if(tmpX > maxX)
finalX = this.sizeX - tmpX;
int tmpY = Math.abs((int)targetCoordinates.getY() - (int)sourceCoordinates.getY());
int finalY = tmpY;
if(tmpY > maxY)
finalY = this.sizeY - tmpY;
return finalX + finalY;
}
/*
* Input: GLOBAL coordinate of the source and the name of the agent in order to
* understand which map to look at
*
* Output: returns the minimum distance to the closest entity (dispenser, taskboard, goal position)
*
*/
private int getMinimalDistanceFromAll(Point sourceCoordinates, String agentName) {
Map<String, Set<Point>> agentMap = this.agentmaps.get(agentName);
Set<Point> coordinatesToCheck = new HashSet<Point>();
//Putting all coordinates of known dispensers/goals/taskboards together
for(String key : agentMap.keySet())
coordinatesToCheck.addAll(agentMap.get(key));
//Fictitious value known to be greater than any minimal distance
int minimalDistance = this.sizeX + this.sizeY;
for(Point target : coordinatesToCheck) {
int minimalDistanceFromTarget = getMinimalDistanceFromTarget(sourceCoordinates, target);
if(minimalDistanceFromTarget < minimalDistance)
minimalDistance = minimalDistanceFromTarget;
}
return minimalDistance;
}
/*
* Input: agent name (to use the right map), starting coordinates and their minimal distance from known entities
*
* Output: the reachable cell which is further away from known entities starting from the given coordinates
*
*/
private Point getSinkFromCell(String agentName, Point sourceCoordinates, int sourceMinimalDistance) {
Point nextCell = sourceCoordinates;
int maximalDistance = sourceMinimalDistance;
//Computing coordinates and minimal distances of neighbour cells
Point northCell = new Point((int)sourceCoordinates.getX(), ((int)sourceCoordinates.getY() - 1) % this.sizeY);
int minimalNorth = getMinimalDistanceFromAll(northCell, agentName);
Point eastCell = new Point(((int)sourceCoordinates.getX() + 1) % this.sizeX, (int)sourceCoordinates.getY());
int minimalEast = getMinimalDistanceFromAll(eastCell, agentName);
Point southCell = new Point((int)sourceCoordinates.getX(), ((int)sourceCoordinates.getY() + 1) % this.sizeY);
int minimalSouth = getMinimalDistanceFromAll(southCell, agentName);
Point westCell = new Point(((int)sourceCoordinates.getX() - 1) % this.sizeX, (int)sourceCoordinates.getY());
int minimalWest = getMinimalDistanceFromAll(westCell, agentName);
//update the maximal distance if one of the neighbours is further away from a known entity
if(maximalDistance < minimalNorth) {
nextCell = northCell;
maximalDistance = minimalNorth;
}
if(maximalDistance < minimalEast) {
nextCell = eastCell;
maximalDistance = minimalEast;
}
if(maximalDistance < minimalSouth) {
nextCell = southCell;
maximalDistance = minimalSouth;
}
if(maximalDistance < minimalWest) {
nextCell = westCell;
maximalDistance = minimalWest;
}
//Recursive call if the maximal distance has changed
if(maximalDistance != sourceMinimalDistance)
return getSinkFromCell(agentName, nextCell, maximalDistance);
//Otherwise
return nextCell;
}
/*
* Sven's suggestion
*
* Input: agent name (to use the right map) and its coordinates
*
* Output: coordinates of a sink reachable from the vision edge of the agent
*
* NOTE: this method can be reduced to very few lines by using a Pair class and an auxiliary method. I didn't find a Pair class
* on the spot and didn't want to implement one...
*/
private Point getSinkFromAgentPosition(String agentName, Point agentCoordinates) {
Point startingCell = agentCoordinates;
int maximalDistance = -1;
//checking the north cell
Point tmpCell = new Point((int)agentCoordinates.getX(), ((int)agentCoordinates.getY() - 5) % this.sizeY);
int tmpDistance = getMinimalDistanceFromAll(tmpCell, agentName);
if(maximalDistance < tmpDistance) {
maximalDistance = tmpDistance;
startingCell = tmpCell;
}
//checking the east cell
tmpCell = new Point(((int)agentCoordinates.getX() + 5) % this.sizeX, (int)agentCoordinates.getY());
tmpDistance = getMinimalDistanceFromAll(tmpCell, agentName);
if(maximalDistance < tmpDistance) {
maximalDistance = tmpDistance;
startingCell = tmpCell;
}
//checking the south cell
tmpCell = new Point((int)agentCoordinates.getX(), ((int)agentCoordinates.getY() + 5) % this.sizeY);
tmpDistance = getMinimalDistanceFromAll(tmpCell, agentName);
if(maximalDistance < tmpDistance) {
maximalDistance = tmpDistance;
startingCell = tmpCell;
}
//checking the west cell
tmpCell = new Point(((int)agentCoordinates.getX() - 5) % this.sizeX, (int)agentCoordinates.getY());
tmpDistance = getMinimalDistanceFromAll(tmpCell, agentName);
if(maximalDistance < tmpDistance) {
maximalDistance = tmpDistance;
startingCell = tmpCell;
}
//checking the other cells at the vision edge
for(int i = 1; i < 5; i++) {
int j = 5 - i;
tmpCell = new Point(((int)agentCoordinates.getX() + i) % this.sizeX, ((int)agentCoordinates.getY() + j) % this.sizeY);
tmpDistance = getMinimalDistanceFromAll(tmpCell, agentName);
if(maximalDistance < tmpDistance) {
maximalDistance = tmpDistance;
startingCell = tmpCell;
}
tmpCell = new Point(((int)agentCoordinates.getX() + i) % this.sizeX, ((int)agentCoordinates.getY() - j) % this.sizeY);
tmpDistance = getMinimalDistanceFromAll(tmpCell, agentName);
if(maximalDistance < tmpDistance) {
maximalDistance = tmpDistance;
startingCell = tmpCell;
}
tmpCell = new Point(((int)agentCoordinates.getX() - i) % this.sizeX, ((int)agentCoordinates.getY() + j) % this.sizeY);
tmpDistance = getMinimalDistanceFromAll(tmpCell, agentName);
if(maximalDistance < tmpDistance) {
maximalDistance = tmpDistance;
startingCell = tmpCell;
}
tmpCell = new Point(((int)agentCoordinates.getX() - i) % this.sizeX, ((int)agentCoordinates.getY() - j) % this.sizeY);
tmpDistance = getMinimalDistanceFromAll(tmpCell, agentName);
if(maximalDistance < tmpDistance) {
maximalDistance = tmpDistance;
startingCell = tmpCell;
}
}
return getSinkFromCell(agentName, startingCell, maximalDistance);
}
/*
*
* Input: the agent name to use the right map
*
* Output: the best cell among a bunch of cells on the map
*
*
*/
private Point getDestinationFromRandomPoints(String agentName) {
//paramenters to play with
int xDistance = 20;
int yDistance = 20;
int xIterations = this.sizeX / xDistance;
int yIterations = this.sizeY / yDistance;
//actual algorithm
int maximalDistance = - 1;
Point returnedPoint = null;
for(int x = 0; x <= xIterations; x++)
for(int y = 0; y <= yIterations; y++) {
Point tmpCell = new Point(x * xDistance, y * yDistance);
int tmpDistance = getMinimalDistanceFromAll(tmpCell, agentName);
if(maximalDistance < tmpDistance) {
maximalDistance = tmpDistance;
returnedPoint = tmpCell;
}
}
return returnedPoint;
}
/*
*
* Like the method above, but looks for a sink starting from the returned point
*
*/
private Point getSinkFromRandomPoint(String agentName) {
Point startingCell = getDestinationFromRandomPoints(agentName);
return getSinkFromCell(agentName, startingCell, getMinimalDistanceFromAll(startingCell, agentName));
}
/*
* Input: agent name (to use the right map), its GLOBAL coordinates and the variables to store the coordinates of the destination
*
*/
@OPERATION
void getExplorerDestination(String agentName, int agentX, int agentY, OpFeedbackParam<Integer> destinationX, OpFeedbackParam<Integer> destinationY) {
//Three possibility so far, uncomment the one you want to try
Point destination = getSinkFromAgentPosition(agentName, new Point(agentX, agentY));
//Point destination = getDestinationFromRandomPoints(agentName)
//Point destination = getSinkFromRandomPoint(agentName);
destinationX.set((int)destination.getX());
destinationY.set((int)destination.getY());
}
public class Team {
int targetTaskX;
int targetTaskY;
int targetGoalX;
int targetGoalY;
List<Point> retrieversAvailablePositions = new ArrayList<>();
Map<String, String> agentAvailable = new HashMap<String, String>();
List<Pair<String, String>> ourBlocks = new ArrayList<>();
public Team(int targetTaskX, int targetTaskY, int targetGoalX, int targetGoalY, List<Point> retrieversAvailablePositions) {
this.targetTaskX = targetTaskX;
this.targetTaskY = targetTaskY;
this.targetGoalX = targetGoalX;
this.targetGoalY = targetGoalY;
this.retrieversAvailablePositions.addAll(retrieversAvailablePositions);
this.agentAvailable.clear();
this.ourBlocks.clear();
}
public int getTargetTaskX()
{
return targetTaskX;
}
public int getTargetTaskY()
{
return targetTaskY;
}
public int getTargetGoalX()
{
return targetGoalX;
}
public int getTargetGoalY()
{
return targetGoalY;
}
public List<Point> getRetrieversAvailablePositions()
{
return retrieversAvailablePositions;
}
public void setTargetTaskX(int x)
{
this.targetTaskX = x;
}
public void setTargetTaskY(int y)
{
this.targetTaskY = y;
}
public void setTargetGoalX(int x)
{
this.targetGoalX = x;
}
public void setTargetGoalY(int y)
{
this.targetGoalY = y;
}
public void setRetrieversAvailablePositions(List<Point> list)
{
this.retrieversAvailablePositions.clear();
this.retrieversAvailablePositions.addAll(list);
}
public void addRetrieversAvailablePositions(int x, int y) {
this.retrieversAvailablePositions.add(new Point(x,y));
}
public Map<String, String> getAgentAvailable()
{
return agentAvailable;
}
public String getAgentAvailableType(String name)
{
return agentAvailable.get(name);
}
public void addAgentAvailable(String name, String type) {
this.agentAvailable.put(name,type);
}
public void removeAgentAvailable(String name) {
this.agentAvailable.remove(name);
}
public List<Pair<String, String>> getTheBlocks()
{
return ourBlocks;
}
public void addBlock(String ag, String b) {
this.ourBlocks.add(new Pair<String, String>(ag, b));
}
public void removeBlock(String ag) {
this.ourBlocks.removeIf(p -> p.getFirst().equals(ag));
}
}
}
| 50,632 | 32.665559 | 173 | java |
mapc2020-lfc | mapc2020-lfc-master/src/env/env/EISArtifact.java | package env;
import jason.JasonException;
import jason.NoValueException;
import jason.asSyntax.*;
import java.awt.Point;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
import java.util.logging.Logger;
import cartago.AgentId;
import cartago.Artifact;
import cartago.INTERNAL_OPERATION;
import cartago.OPERATION;
import cartago.ObsProperty;
import cartago.OpFeedbackParam;
import eis.AgentListener;
import eis.EnvironmentListener;
import eis.exceptions.*;
import eis.iilang.*;
import massim.eismassim.EnvironmentInterface;
public class EISArtifact extends Artifact implements AgentListener {
private Logger logger = Logger.getLogger(EISArtifact.class.getName());
private Map<String, AgentId> agentIds;
private Map<String, String> agentToEntity;
private List<Literal> start = new ArrayList<Literal>();
private List<Literal> percs = new ArrayList<Literal>();
// private List<Literal> signalList = new ArrayList<Literal>();
private List<Literal> obstacleList = new ArrayList<Literal>();
private List<Literal> blockList = new ArrayList<Literal>();
private Point mypos = new Point(0,0);
private EnvironmentInterface ei = null;
private boolean receiving;
private int lastStep = -1;
public EISArtifact() {
agentIds = new ConcurrentHashMap<String, AgentId>();
agentToEntity = new ConcurrentHashMap<String, String>();
}
protected void init(String config) throws IOException, InterruptedException {
ei = new EnvironmentInterface(config);
try {
ei.start();
} catch (ManagementException e) {
e.printStackTrace();
}
ei.attachEnvironmentListener(new EnvironmentListener() {
public void handleNewEntity(String entity) {}
public void handleStateChange(EnvironmentState s) {
logger.info("new state "+s);
}
public void handleDeletedEntity(String arg0, Collection<String> arg1) {}
public void handleFreeEntity(String arg0, Collection<String> arg1) {}
});
}
@OPERATION
void statusRequest() {
logger.info("STATE:");
}
@OPERATION
void register(String entity) {
String agent = getCurrentOpAgentId().getAgentName();
logger = Logger.getLogger(EISArtifact.class.getName()+"_"+agent);
logger.info("Registering " + agent + " to entity " + entity);
try {
ei.registerAgent(agent);
} catch (Exception e) {
e.printStackTrace();
}
ei.attachAgentListener(agent, this);
try {
ei.associateEntity(agent, entity);
} catch (Exception e) {
e.printStackTrace();
}
agentToEntity.put(agent, entity);
agentIds.put(agent, getCurrentOpAgentId());
if (ei != null) {
receiving = true;
execInternalOp("receiving", agent);
}
}
@OPERATION
void action(String action) throws NoValueException {
try {
Literal literal = Literal.parseLiteral(action);
String agent = getCurrentOpAgentId().getAgentName();
Action a = Translator.literalToAction(literal);
ei.performAction(agent, a);
// long endTime = System.nanoTime();
// long duration = (endTime - startTime) / 1000000;
// logger.info("Executed action "+a+" step "+lastStep+". Time from percept: "+duration);
} catch (Exception e) {
e.printStackTrace();
}
}
@INTERNAL_OPERATION
void receiving(String agent) throws JasonException {
lastStep = -1;
Collection<Percept> previousPercepts = new ArrayList<Percept>();
// await_time(1000);
while(!ei.isEntityConnected(agentToEntity.get(agent)))
await_time(100);
while (receiving) {
await_time(100);
if (ei != null) {
try {
// if (ei.getAllPercepts(agent).get(agentToEntity.get(agent))) {
Collection<Percept> percepts = ei.getAllPercepts(agent).get(agentToEntity.get(agent));
if (!percepts.isEmpty()) {
// startTime = System.nanoTime();
// logger.info("***"+percepts);
// if (agent.equals("vehicle1")) { logger.info("***"+percepts); }
int currentStep = getCurrentStep(percepts);
if (lastStep != currentStep) { // only updates if it is a new step
lastStep = currentStep;
//logger.info("Agent "+agent);
updatePerception(agent, previousPercepts, percepts);
previousPercepts = percepts;
}
}
// }
} catch (PerceiveException | NoEnvironmentException e) {
e.printStackTrace();
}
}
}
}
private int getCurrentStep(Collection<Percept> percepts) throws JasonException {
obstacleList.clear();
blockList.clear();
int step = -10;
for (Percept percept : percepts) {
if (percept.getName().equals("step")) {
//logger.info(percept+" "+percept.getParameters().getFirst());
step = new Integer(percept.getParameters().get(0).toString());
}
else if (percept.getName().equals("obstacle")) {
Literal literal = Translator.perceptToLiteral(percept);
obstacleList.add(literal);
}
else if (percept.getName().equals("thing") && (percept.getParameters().get(2).toString().equals("block") || percept.getParameters().get(2).toString().equals("entity"))) {
Literal literal = Translator.perceptToLiteral(percept);
if((int)((NumberTerm) literal.getTerm(0)).solve() != 0 || (int)((NumberTerm) literal.getTerm(1)).solve() != 0)
blockList.add(literal);
}
}
// logger.info("@@@@ "+obstacleList);
// logger.info("@@@@ "+blockList);
return step;
}
private void updatePerception(String agent, Collection<Percept> previousPercepts, Collection<Percept> percepts) throws JasonException {
for (Percept old: previousPercepts) {
if (step_obs_prop.contains(old.getName())) {
if (!percepts.contains(old) || old.getName().equals("lastAction") || old.getName().equals("lastActionResult") || old.getName().equals("lastActionParams") || old.getName().equals("goal") || old.getName().equals("thing")) { // not perceived anymore
Literal literal = Translator.perceptToLiteral(old);
try{
removeObsPropertyByTemplate(old.getName(), (Object[]) literal.getTermsArray());
}
catch (Exception e) {
logger.info("error removing old perception "+literal+" "+e.getMessage());
logger.info("P*** "+percepts);
logger.info("O*** "+previousPercepts);
}
// logger.info("removing old perception "+literal);
}
}
}
// compute new perception
Literal step = null;
Literal lastAction = null;
Literal lastActionResult = null;
Literal lastActionParams = null;
Literal actionID = null;
for (Percept percept: percepts) {
if ( step_obs_prop.contains(percept.getName()) ) {
if (!previousPercepts.contains(percept) || percept.getName().equals("lastAction") || percept.getName().equals("lastActionResult") || percept.getName().equals("lastActionParams") || percept.getName().equals("goal") || percept.getName().equals("thing")) { // really new perception
Literal literal = Translator.perceptToLiteral(percept);
if (percept.getName().equals("step")) {
step = literal;
} else if (percept.getName().equals("simEnd")) {
defineObsProperty(percept.getName(), (Object[]) literal.getTermsArray());
cleanObsProps(match_obs_prop);
lastStep = -1;
break;
} else {
if (percept.getName().equals("lastActionResult")) {
lastActionResult = literal;
}
else if (percept.getName().equals("lastAction")) { lastAction = literal; }
else if (percept.getName().equals("lastActionParams")) { lastActionParams = literal; }
else if (percept.getName().equals("actionID")) { actionID = literal; }
else {
percs.add(literal);
}
}
}
} if (match_obs_prop.contains(percept.getName())) {
Literal literal = Translator.perceptToLiteral(percept);
start.add(literal);
}
}
if (!start.isEmpty()) {
for (Literal lit: start) {
defineObsProperty(lit.getFunctor(), (Object[]) lit.getTermsArray());
}
start.clear();
}
if (step != null) {
if (lastAction.getTerm(0).toString().equals("move") && lastActionResult.getTerm(0).toString().equals("success")) {
if (lastActionParams.getTerm(0).toString().contains("n")) { mypos.y--; }
else if (lastActionParams.getTerm(0).toString().contains("s")) { mypos.y++; }
else if (lastActionParams.getTerm(0).toString().contains("e")) { mypos.x++; }
else if (lastActionParams.getTerm(0).toString().contains("w")) { mypos.x--; }
}
// logger.info("My current position is X = "+mypos.x+" Y = "+mypos.y+" Step "+step);
defineObsProperty(step.getFunctor(), (Object[]) step.getTermsArray());
defineObsProperty(lastAction.getFunctor(), (Object[]) lastAction.getTermsArray());
defineObsProperty(lastActionResult.getFunctor(), (Object[]) lastActionResult.getTermsArray());
defineObsProperty(lastActionParams.getFunctor(), (Object[]) lastActionParams.getTermsArray());
for (Literal lit: percs) {
defineObsProperty(lit.getFunctor(), (Object[]) lit.getTermsArray());
}
percs.clear();
// if (!signalList.isEmpty()) {
// for (Literal lit: signalList) {
// signal(agentIds.get(agent),lit.getFunctor(),(Object[]) lit.getTermsArray());
// }
// signalList.clear();
// }
defineObsProperty(actionID.getFunctor(), (Object[]) actionID.getTermsArray());
}
}
private void cleanObsProps(Set<String> obSet) {
for (String obs: obSet) {
cleanObsProp(obs);
}
}
private void cleanObsProp(String obs) {
ObsProperty ob = getObsProperty(obs);
while (ob != null) {
// logger.info("Removing "+ob);
removeObsProperty(obs);
ob = getObsProperty(obs);
}
}
@OPERATION
void stopReceiving() {
receiving = false;
}
@OPERATION
void getMyPos(OpFeedbackParam<Integer> x, OpFeedbackParam<Integer> y){
// if (sizeX != 0) {
// if (mypos.x % sizeX < 0) {
// x.set(mypos.x % sizeX + sizeX);
// } else {
// x.set(mypos.x % sizeX);
// }
// } else {
x.set(mypos.x);
// }
// if (sizeY != 0) {
// if (mypos.y % sizeY < 0) {
// y.set(mypos.y % sizeY + sizeY);
// } else {
// y.set(mypos.y % sizeY);
// }
// } else {
y.set(mypos.y);
// }
}
@OPERATION
void updateMyPos(int originx, int originy){
mypos.x = mypos.x + originx;
mypos.y = mypos.y + originy;
}
@OPERATION
void resetMyPos(){
mypos.x = 0;
mypos.y = 0;
}
static Set<String> match_obs_prop = new HashSet<String>( Arrays.asList(new String[] {
"name",
"steps",
"team",
"vision",
"teamSize"
}));
static Set<String> step_obs_prop = new HashSet<String>( Arrays.asList(new String[] {
"actionID",
"step",
"simEnd",
"lastAction",
"lastActionResult",
"score",
"thing",
"task",
"obstacle",
"goal",
"attached",
"lastActionParams",
"energy",
"disabled",
// "timestamp",
// "deadline",
}));
@Override
public void handlePercept(String agent, Percept percept) {}
//Planner related methods
// all coordinates are assumed to be visible to the agent
private Literal[] convertToAgentPlan(List<String> returnedPlan) {
if(returnedPlan == null)
return new Literal[0];
// logger.info(returnedPlan + "");
List<Literal> actions = new ArrayList<Literal>();
for(String action : returnedPlan) {
int par = action.indexOf("(");
String functor = action.substring(0, par);
// logger.info(functor + "(");
List<Term> args = new ArrayList<>();
for(String arg : action.substring(par + 1, action.length() - 1).split(",")) {
// logger.info(arg);
args.add(ASSyntax.createAtom(arg));
}
// logger.info(")");
actions.add(ASSyntax.createLiteral(functor, args.toArray(new Term[args.size()])));
}
return actions.toArray(new Literal[actions.size()]);
}
// NOTE: clear is supposed to be true if the clear action is allowed, false otherwise.
@OPERATION
public void getPlanAgentToGoal(String agent, int goalX, int goalY, OpFeedbackParam<Literal[]> plan, int clear) {
String goalCell = coordinate2String(goalX) + coordinate2String(goalY);
String goalStatement = createGoalStatement("(at a " + goalCell + ")");
// logger.info("Goal statement: " + goalStatement);
String code;
try {
code = generateCode("agent", goalX, goalY, clear);
LinkedList<String> returnedPlan = getPlan(agent, goalStatement, null, 0, clear, code);
plan.set(convertToAgentPlan(returnedPlan));
} catch (NoValueException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@OPERATION
public void getPlanAgentToGoal(String agent, int goalX, int goalY, int blockX, int blockY, OpFeedbackParam<Literal[]> plan, int clear) {
String goalCell = coordinate2String(goalX) + coordinate2String(goalY);
String attachedBlockCell = coordinate2String(blockX) + coordinate2String(blockY);
String goalStatement = createGoalStatement("(at a " + goalCell + ")");
// logger.info("Goal statement: " + goalStatement);
try {
String code = generateCode("agent", goalX, goalY, blockX, blockY, clear);
LinkedList<String> returnedPlan = getPlan(agent, goalStatement, attachedBlockCell, 1, clear, code);
plan.set(convertToAgentPlan(returnedPlan));
} catch (NoValueException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@OPERATION
public void getPlanBlockToGoal(String agent, int goalX, int goalY, int blockX, int blockY, OpFeedbackParam<Literal[]> plan, int clear) {
String goalCell = coordinate2String(goalX) + coordinate2String(goalY);
String attachedBlockCell = coordinate2String(blockX) + coordinate2String(blockY);
String goalStatement = createGoalStatement("(at b0 " + goalCell + ")");
// logger.info("Goal statement: " + goalStatement);
String code;
try {
code = generateCode("block", goalX, goalY, blockX, blockY, clear);
LinkedList<String> returnedPlan = getPlan(agent, goalStatement, attachedBlockCell, 1, clear, code);
plan.set(convertToAgentPlan(returnedPlan));
} catch (NoValueException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private String createGoalStatement(String actualGoal) {
return "\t(:goal " + actualGoal + ")";
}
private String generateCode(String what, int goalX, int goalY, int blockX, int blockY, int clear) throws NoValueException {
List<List<Integer>> vision = new ArrayList<>();
for(int i = 0, nCells = 1; i < 11; i++, nCells += 2) {
vision.add(new ArrayList<>(Collections.nCopies(nCells, 0)));
if(i >= 5) nCells -= 2;
else nCells += 2;
}
for(Literal l : this.blockList) {
int x = (int)((NumberTerm) l.getTerm(0)).solve();
int y = (int)((NumberTerm) l.getTerm(1)).solve();
vision.get(5 + y).set(5 + x - Math.abs(y), 1);
}
for(Literal l : this.obstacleList) {
int x = (int)((NumberTerm) l.getTerm(0)).solve();
int y = (int)((NumberTerm) l.getTerm(1)).solve();
vision.get(5 + y).set(5 + x - Math.abs(y), 2);
}
String code = "b" + blockX + blockY;
code += (what.equals("agent") ? "ga" : "gb") + (goalX + "" + goalY + "-");
code += clear == 1 ? "cl" : "ncl";
for(int i = 0, nCells = 1; i < 11; i++) {
for(int j = 0; j < nCells; j++) {
code += vision.get(i).get(j);
}
if(i >= 5) nCells -= 2;
else nCells += 2;
}
return code;
}
private String generateCode(String what, int goalX, int goalY, int clear) throws NoValueException {
List<List<Integer>> vision = new ArrayList<>();
for(int i = 0, nCells = 1; i < 11; i++, nCells += 2) {
vision.add(new ArrayList<>(Collections.nCopies(nCells, 0)));
if(i >= 5) nCells -= 2;
else nCells += 2;
}
//logger.info("blocklist: " + this.blockList);
for(Literal l : this.blockList) {
// logger.info(l.toString());
int x = (int)((NumberTerm) l.getTerm(0)).solve();
// logger.info("x: " + x);
int y = (int)((NumberTerm) l.getTerm(1)).solve();
// logger.info("y: " + y);
// logger.info("(" + (5+x-Math.abs(y)) + "," + (5+y) + ")");
// logger.info("length: " + vision.get(5 + y).size());
vision.get(5 + y).set(5 + x - Math.abs(y), 1);
}
//logger.info("obstacleList: " + this.obstacleList);
for(Literal l : this.obstacleList) {
// logger.info(l.toString());
int x = (int)((NumberTerm) l.getTerm(0)).solve();
// logger.info("x: " + x);
int y = (int)((NumberTerm) l.getTerm(1)).solve();
// logger.info("y: " + y);
// logger.info("(" + (5+x-Math.abs(y)) + "," + (5+y) + ")");
// logger.info("length: " + vision.get(5 + y).size());
vision.get(5 + y).set(5 + x - Math.abs(y), 2);
}
String code = "nb";
code += (what.equals("agent") ? "ga" : "gb") + (goalX + "" + goalY + "-");
code += clear == 1 ? "cl" : "ncl";
// logger.info("here0");
for(int i = 0, nCells = 1; i < 11; i++) {
for(int j = 0; j < nCells; j++) {
code += vision.get(i).get(j);
}
if(i >= 5) nCells -= 2;
else nCells += 2;
}
// logger.info("here1");
return code;
}
private LinkedList<String> getPlan(String agent, String goalStatement, String attachedBlockCoordinates, int blockCounter, int clear, String code) {
LinkedList<String> plan = null;
// check if the plan is already in the cache
if(new File("./planner/cache/" + code).exists()) {
// logger.info("Get the plan from cache");
try {
synchronized (EISArtifact.class) {
Scanner s = new Scanner(new FileInputStream("./planner/cache/" + code));
plan = new LinkedList<String>();
while(s.hasNextLine()) {
String line = s.nextLine();
plan.add(line);
}
s.close();
if(!plan.isEmpty() && plan.get(0).equals("NO PLAN")) {
return null;
}
return plan;
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// logger.info("The plan is not cached, so I have to compute one");
new File("./planner/" + agent + "_problem.pddl").delete();
// if(new File("./planner/" + agent + "_problem.pddl").delete())
// logger.info("DELETED " + agent +"_problem.pddl");
new File("./planner/" + agent).delete();
// if(new File("./planner/" + agent).delete())
// logger.info("DELETED " + agent);
try {
// logger.info("We are in the getPlan method!");
Set<String> nonEmptyCells = new HashSet<String>();
nonEmptyCells.add("p0p0");
String problemFileName = agent + "_problem.pddl";
File problemFile = new File("planner/" + problemFileName);
FileWriter problemFileWriter = new FileWriter(problemFile);
String outputFileName = agent + "_output";
String preamble = "(define (problem " + agent + ")\n"
+ "\t(:domain mapc)\n";
problemFileWriter.write(preamble);
List<String> blocks = new LinkedList<String>();
List<String> obstacles = new LinkedList<String>();
List<String> initBlocksObstacles = new LinkedList<String>();
int obstaclesNumber = 0;
int blocksNumber = blockCounter;
//Analysing blocks list
for(Literal l : this.blockList) {
int x = (int)((NumberTerm) l.getTerm(0)).solve();
int y = (int)((NumberTerm) l.getTerm(1)).solve();
String cell = coordinate2String(x) + coordinate2String(y);
String blockID = null;
if(cell.equals(attachedBlockCoordinates))
blockID = "b0";
else {
blockID = "b" + blocksNumber;
blocksNumber++;
}
nonEmptyCells.add(cell);
blocks.add(blockID);
initBlocksObstacles.add("(at " + blockID + " " + cell + ")");
}
//Analysing obstacles list
for(Literal l : this.obstacleList) {
int x = (int)((NumberTerm) l.getTerm(0)).solve();
int y = (int)((NumberTerm) l.getTerm(1)).solve();
String cell = coordinate2String(x) + coordinate2String(y);
String obstaclesID = "o" + obstaclesNumber;
obstaclesNumber++;
nonEmptyCells.add(cell);
obstacles.add(obstaclesID);
initBlocksObstacles.add("(at " + obstaclesID + " " + cell + ")");
}
//Creating the :objects field
String objects = "\t(:objects\n";
String blocksDeclaration = "\t\t";
for(String b : blocks)
blocksDeclaration += b + " ";
if(!blocksDeclaration.equals("\t\t"))
objects += blocksDeclaration + "- block\n";
String obstaclesDeclaration = "\t\t";
for(String o : obstacles)
obstaclesDeclaration += o + " ";
if(!obstaclesDeclaration.equals("\t\t"))
objects += obstaclesDeclaration + "- obstacle\n";
objects += "\t)\n";
// writing objects to file
if(!this.obstacleList.isEmpty() || !this.blockList.isEmpty())
problemFileWriter.write(objects.toString());
// writing :init field
problemFileWriter.write("\t(:init\n");
problemFileWriter.write("\t\t(rotation cw n e)\n");
problemFileWriter.write("\t\t(rotation cw e s)\n");
problemFileWriter.write("\t\t(rotation cw s w)\n");
problemFileWriter.write("\t\t(rotation cw w n)\n");
problemFileWriter.write("\t\t(rotation ccw n w)\n");
problemFileWriter.write("\t\t(rotation ccw w s)\n");
problemFileWriter.write("\t\t(rotation ccw s e)\n");
problemFileWriter.write("\t\t(rotation ccw e n)\n");
problemFileWriter.write("\t\t(at a p0p0)\n");
problemFileWriter.write("\t\t(= (total-cost) 0)\n");
if(attachedBlockCoordinates == null)
problemFileWriter.write("\t\t(alone a)\n");
else
problemFileWriter.write("\t\t(attached a b0)\n");
for(int i = -5; i < 6; i++) {
int init_j = 5 - Math.abs(i);
for(int j = -init_j; j < init_j + 1; j++) {
String cellName = coordinate2String(j) + coordinate2String(i);
if(!nonEmptyCells.contains(cellName))
problemFileWriter.write("\t\t(empty " + cellName + ")\n");
if( Math.abs(j) + Math.abs(i - 1) < 6 )
problemFileWriter.write("\t\t(adjacent n " + cellName + " " + coordinate2String(j) + coordinate2String(i - 1) + ")\n");
if( Math.abs(j + 1) + Math.abs(i) < 6 )
problemFileWriter.write("\t\t(adjacent e " + cellName + " " + coordinate2String(j + 1) + coordinate2String(i) + ")\n");
if( Math.abs(j) + Math.abs(i + 1) < 6 )
problemFileWriter.write("\t\t(adjacent s " + cellName + " " + coordinate2String(j) + coordinate2String(i + 1) + ")\n");
if( Math.abs(j - 1) + Math.abs(i) < 6 )
problemFileWriter.write("\t\t(adjacent w " + cellName + " " + coordinate2String(j - 1) + coordinate2String(i) + ")\n");
}
}
for(String otherInit : initBlocksObstacles)
problemFileWriter.write("\t\t" + otherInit + "\n");
problemFileWriter.write("\t)\n");
// writing goal
problemFileWriter.write(goalStatement + "\n");
//metric + end bracket
problemFileWriter.write("\t(:metric minimize (total-cost))\n)");
problemFileWriter.flush();
problemFileWriter.close();
plan = callPlanner2(agent, clear, code);
} catch (Exception e) {
logger.info("Exception while invoking the planner, here is the returned error message:");
logger.info(e.getMessage());
plan = null;
}
return plan;
}
private LinkedList<String> callPlanner(String agentName, int clear) throws IOException, InterruptedException {
String problem = agentName + "_problem.pddl";
String output = agentName + "_output";
// logger.info("problem file name: " + problem);
// logger.info("output file name: " + output);
ProcessBuilder pb = null;
if(clear == 1)
pb = new ProcessBuilder("./run.sh", "domain_clear.pddl", agentName);
else
pb = new ProcessBuilder("./run.sh", "domain.pddl", agentName);
pb.directory(new File("./planner"));
Process p = pb.start();
p.waitFor();
File planResult = new File("./planner/" + agentName);
if(!planResult.exists()) {
logger.info("NO PLAN returned or problems with the planner invocation");
return null;
}
Scanner s = new Scanner(planResult);
LinkedList<String> plan = new LinkedList<String>();
while(s.hasNextLine()) {
String line = s.nextLine();
plan.add(line);
}
s.close();
// logger.info("We have a plan!");
return plan;
}
private LinkedList<String> callPlanner2(String agentName, int clear, String code) throws IOException, InterruptedException {
String problem = agentName + "_problem.pddl";
String output = agentName + "_output";
// logger.info("problem file name: " + problem);
// logger.info("output file name: " + output);
ProcessBuilder pb = null;
if(clear == 1)
pb = new ProcessBuilder("./run2.sh", "domain_clear.pddl", agentName);
else
pb = new ProcessBuilder("./run2.sh", "domain.pddl", agentName);
pb.directory(new File("./planner"));
Process p = pb.start();
p.waitFor();
Scanner s = new Scanner(p.getInputStream());
LinkedList<String> plan = new LinkedList<String>();
synchronized (EISArtifact.class) {
FileWriter cachedPlan = new FileWriter("./planner/cache/" + code);
while(s.hasNextLine()) {
String line = s.nextLine();
cachedPlan.write(line + "\n");
if(line.equals("NO PLAN")) {
s.close();
cachedPlan.close();
return null;
}
plan.add(line);
}
cachedPlan.close();
s.close();
}
// logger.info("We have a plan!");
return plan;
}
private String coordinate2String(int coordinate) {
if(coordinate < 0)
return "n" + Math.abs(coordinate);
return "p" + coordinate;
}
} | 26,680 | 32.518844 | 283 | java |
mapc2020-lfc | mapc2020-lfc-master/src/env/env/Translator.java | package env;
import jason.JasonException;
import jason.NoValueException;
import jason.asSyntax.ASSyntax;
import jason.asSyntax.ListTerm;
import jason.asSyntax.ListTermImpl;
import jason.asSyntax.Literal;
import jason.asSyntax.NumberTerm;
import jason.asSyntax.StringTerm;
import jason.asSyntax.Structure;
import jason.asSyntax.Term;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import eis.iilang.Action;
import eis.iilang.Function;
import eis.iilang.Identifier;
import eis.iilang.Numeral;
import eis.iilang.Parameter;
import eis.iilang.ParameterList;
import eis.iilang.Percept;
public class Translator {
public static Literal perceptToLiteral(Percept per) throws JasonException {
Literal l = ASSyntax.createLiteral(per.getName());
for (Parameter par : per.getParameters())
l.addTerm(parameterToTerm(per, par));
return l;
}
public static Percept literalToPercept(jason.asSyntax.Literal l) throws NoValueException {
Percept p = new Percept(l.getFunctor());
for (Term t : l.getTerms())
p.addParameter(termToParameter(t));
return p;
}
public static Action literalToAction(Literal action) throws NoValueException {
Parameter[] pars = new Parameter[action.getArity()];
for (int i = 0; i < action.getArity(); i++)
pars[i] = termToParameter(action.getTerm(i));
return new Action(action.getFunctor(), pars);
}
public static Parameter termToParameter(Term t) throws NoValueException {
if (t.isNumeric()) {
double d = ((NumberTerm) t).solve();
if((d == Math.floor(d)) && !Double.isInfinite(d)) return new Numeral((int)d);
return new Numeral(d);
} else if (t.isList()) {
List<Parameter> terms = new ArrayList<>();
for (Term listTerm : (ListTerm) t)
terms.add(termToParameter(listTerm));
return new ParameterList(terms);
} else if (t.isString()) {
return new Identifier(((StringTerm) t).getString());
} else if (t.isLiteral()) {
Literal l = (Literal) t;
if (!l.hasTerm()) {
return new Identifier(l.getFunctor());
} else {
Parameter[] terms = new Parameter[l.getArity()];
for (int i = 0; i < l.getArity(); i++)
terms[i] = termToParameter(l.getTerm(i));
return new Function(l.getFunctor(), terms);
}
}
return new Identifier(t.toString());
}
public static Term parameterToTerm(Percept per, Parameter par) throws JasonException {
if (par instanceof Numeral) {
return ASSyntax.createNumber(((Numeral) par).getValue().doubleValue());
} else if (par instanceof Identifier) {
try {
Identifier i = (Identifier) par;
String a = i.getValue();
if (!Character.isUpperCase(a.charAt(0)))
return ASSyntax.parseTerm(a);
} catch (Exception e) {
}
return ASSyntax.createString(((Identifier) par).getValue());
} else if (par instanceof ParameterList) {
ListTerm list = new ListTermImpl();
ListTerm tail = list;
for (Parameter p : (ParameterList) par)
tail = tail.append(parameterToTerm(per, p));
return list;
} else if (par instanceof Function) {
return filter(per, par);
}
throw new JasonException("The type of parameter " + par + " is unknown!");
}
public static Structure filter(Percept per, Parameter par) throws JasonException{
Function f = (Function) par;
String name = f.getName();
Structure l = ASSyntax.createStructure(name);
if(name.equals("availableItem")){
l = ASSyntax.createStructure("item");
}
for (Parameter p : f.getParameters())
l.addTerm(parameterToTerm(per, p));
if(per.getName().equals("shop") && name.equals("item")){
l.addTerm(ASSyntax.createNumber(0));
l.addTerm(ASSyntax.createNumber(0));
l.addTerm(ASSyntax.createNumber(0));
}
return l;
}
}
| 3,688 | 30.801724 | 91 | java |
mapc2020-lfc | mapc2020-lfc-master/test/lfc/agentcontest2020/ScenarioRunSampleSim2.java | package lfc.agentcontest2020;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import org.apache.commons.io.FileUtils;
import org.junit.Before;
import org.junit.Test;
import jacamo.infra.JaCaMoLauncher;
import jason.JasonException;
import massim.Server;
public class ScenarioRunSampleSim2 {
@Before
public void cleanUpFolders() throws IOException {
File currentDir = new File("");
String path = currentDir.getAbsolutePath();
ScenarioRunSampleSim2 deletefiles = new ScenarioRunSampleSim2();
deletefiles.delete(5, path + "/logs");
deletefiles.delete(4, path + "/log");
deletefiles.delete(5, path + "/replays");
}
public void delete(long nFiles, String directoryFolder) throws IOException {
File folder = new File(directoryFolder);
if(folder.exists()) {
File[] listFiles = folder.listFiles();
Arrays.sort(listFiles);
for ( int i=0; i < listFiles.length - nFiles ; i++ ){
if (!listFiles[i].getName().equals(".keepfolder")) {
// System.out.println(listFiles[i].getName());
listFiles[i].delete();
FileUtils.deleteDirectory(listFiles[i]);
}
}
}
}
@Before
public void setUp() {
new Thread(new Runnable() {
@Override
public void run() {
try {
Server.main(new String[] {"-conf", "conf/SampleConfigSim2.json", "--monitor"});
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
try {
JaCaMoLauncher.main(new String[] {"lfc-mapc2020-30.jcm"});
} catch (JasonException e) {
System.out.println("Exception: "+e.getMessage());
e.printStackTrace();
}
}
@Test
public void run() {
}
}
| 1,675 | 18.952381 | 88 | java |
mapc2020-lfc | mapc2020-lfc-master/test/lfc/agentcontest2020/ScenarioRunContest2_15.java | package lfc.agentcontest2020;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import org.apache.commons.io.FileUtils;
import org.junit.Before;
import org.junit.Test;
import jacamo.infra.JaCaMoLauncher;
import jason.JasonException;
import massim.Server;
public class ScenarioRunContest2_15 {
@Before
public void cleanUpFolders() throws IOException {
File currentDir = new File("");
String path = currentDir.getAbsolutePath();
ScenarioRunContest2_15 deletefiles = new ScenarioRunContest2_15();
deletefiles.delete(5, path + "/logs");
deletefiles.delete(4, path + "/log");
deletefiles.delete(5, path + "/replays");
}
public void delete(long nFiles, String directoryFolder) throws IOException {
File folder = new File(directoryFolder);
if(folder.exists()) {
File[] listFiles = folder.listFiles();
Arrays.sort(listFiles);
for ( int i=0; i < listFiles.length - nFiles ; i++ ){
if (!listFiles[i].getName().equals(".keepfolder")) {
// System.out.println(listFiles[i].getName());
listFiles[i].delete();
FileUtils.deleteDirectory(listFiles[i]);
}
}
}
}
@Before
public void setUp() {
try {
JaCaMoLauncher.main(new String[] {"lfc-mapc2020-15-contest2.jcm"});
} catch (JasonException e) {
System.out.println("Exception: "+e.getMessage());
e.printStackTrace();
}
}
@Test
public void run() {
}
}
| 1,430 | 19.15493 | 77 | java |
mapc2020-lfc | mapc2020-lfc-master/test/lfc/agentcontest2020/ScenarioRunContest2_50.java | package lfc.agentcontest2020;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import org.apache.commons.io.FileUtils;
import org.junit.Before;
import org.junit.Test;
import jacamo.infra.JaCaMoLauncher;
import jason.JasonException;
import massim.Server;
public class ScenarioRunContest2_50 {
@Before
public void cleanUpFolders() throws IOException {
File currentDir = new File("");
String path = currentDir.getAbsolutePath();
ScenarioRunContest2_50 deletefiles = new ScenarioRunContest2_50();
deletefiles.delete(5, path + "/logs");
deletefiles.delete(4, path + "/log");
deletefiles.delete(5, path + "/replays");
}
public void delete(long nFiles, String directoryFolder) throws IOException {
File folder = new File(directoryFolder);
if(folder.exists()) {
File[] listFiles = folder.listFiles();
Arrays.sort(listFiles);
for ( int i=0; i < listFiles.length - nFiles ; i++ ){
if (!listFiles[i].getName().equals(".keepfolder")) {
// System.out.println(listFiles[i].getName());
listFiles[i].delete();
FileUtils.deleteDirectory(listFiles[i]);
}
}
}
}
@Before
public void setUp() {
try {
JaCaMoLauncher.main(new String[] {"lfc-mapc2020-50-contest2.jcm"});
} catch (JasonException e) {
System.out.println("Exception: "+e.getMessage());
e.printStackTrace();
}
}
@Test
public void run() {
}
}
| 1,430 | 19.15493 | 77 | java |
mapc2020-lfc | mapc2020-lfc-master/test/lfc/agentcontest2020/ScenarioRunSampleTwoTeamsTeamB.java | package lfc.agentcontest2020;
import org.junit.Before;
import org.junit.Test;
import jacamo.infra.JaCaMoLauncher;
import jason.JasonException;
public class ScenarioRunSampleTwoTeamsTeamB {
@Before
public void setUp() {
try {
JaCaMoLauncher.main(new String[] {"lfc-mapc2020-15-TeamB.jcm"});
} catch (JasonException e) {
System.out.println("Exception: "+e.getMessage());
e.printStackTrace();
}
}
@Test
public void run() {
}
} | 457 | 17.32 | 67 | java |
mapc2020-lfc | mapc2020-lfc-master/test/lfc/agentcontest2020/ScenarioRunContest1_15.java | package lfc.agentcontest2020;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import org.apache.commons.io.FileUtils;
import org.junit.Before;
import org.junit.Test;
import jacamo.infra.JaCaMoLauncher;
import jason.JasonException;
import massim.Server;
public class ScenarioRunContest1_15 {
@Before
public void cleanUpFolders() throws IOException {
File currentDir = new File("");
String path = currentDir.getAbsolutePath();
ScenarioRunContest1_15 deletefiles = new ScenarioRunContest1_15();
deletefiles.delete(5, path + "/logs");
deletefiles.delete(4, path + "/log");
deletefiles.delete(5, path + "/replays");
}
public void delete(long nFiles, String directoryFolder) throws IOException {
File folder = new File(directoryFolder);
if(folder.exists()) {
File[] listFiles = folder.listFiles();
Arrays.sort(listFiles);
for ( int i=0; i < listFiles.length - nFiles ; i++ ){
if (!listFiles[i].getName().equals(".keepfolder")) {
// System.out.println(listFiles[i].getName());
listFiles[i].delete();
FileUtils.deleteDirectory(listFiles[i]);
}
}
}
}
@Before
public void setUp() {
try {
JaCaMoLauncher.main(new String[] {"lfc-mapc2020-15-contest1.jcm"});
} catch (JasonException e) {
System.out.println("Exception: "+e.getMessage());
e.printStackTrace();
}
}
@Test
public void run() {
}
}
| 1,430 | 19.15493 | 77 | java |
mapc2020-lfc | mapc2020-lfc-master/test/lfc/agentcontest2020/ScenarioRunSampleTwoTeamsTeamB50.java | package lfc.agentcontest2020;
import org.junit.Before;
import org.junit.Test;
import jacamo.infra.JaCaMoLauncher;
import jason.JasonException;
public class ScenarioRunSampleTwoTeamsTeamB50 {
@Before
public void setUp() {
try {
JaCaMoLauncher.main(new String[] {"lfc-mapc2020-50-TeamB.jcm"});
} catch (JasonException e) {
System.out.println("Exception: "+e.getMessage());
e.printStackTrace();
}
}
@Test
public void run() {
}
} | 459 | 17.4 | 67 | java |
mapc2020-lfc | mapc2020-lfc-master/test/lfc/agentcontest2020/ScenarioRunSampleSim3.java | package lfc.agentcontest2020;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import org.apache.commons.io.FileUtils;
import org.junit.Before;
import org.junit.Test;
import jacamo.infra.JaCaMoLauncher;
import jason.JasonException;
import massim.Server;
public class ScenarioRunSampleSim3 {
@Before
public void cleanUpFolders() throws IOException {
File currentDir = new File("");
String path = currentDir.getAbsolutePath();
ScenarioRunSampleSim3 deletefiles = new ScenarioRunSampleSim3();
deletefiles.delete(5, path + "/logs");
deletefiles.delete(4, path + "/log");
deletefiles.delete(5, path + "/replays");
}
public void delete(long nFiles, String directoryFolder) throws IOException {
File folder = new File(directoryFolder);
if(folder.exists()) {
File[] listFiles = folder.listFiles();
Arrays.sort(listFiles);
for ( int i=0; i < listFiles.length - nFiles ; i++ ){
if (!listFiles[i].getName().equals(".keepfolder")) {
// System.out.println(listFiles[i].getName());
listFiles[i].delete();
FileUtils.deleteDirectory(listFiles[i]);
}
}
}
}
@Before
public void setUp() {
new Thread(new Runnable() {
@Override
public void run() {
try {
Server.main(new String[] {"-conf", "conf/SampleConfigSim3.json", "--monitor"});
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
try {
JaCaMoLauncher.main(new String[] {"lfc-mapc2020-50.jcm"});
} catch (JasonException e) {
System.out.println("Exception: "+e.getMessage());
e.printStackTrace();
}
}
@Test
public void run() {
}
}
| 1,675 | 18.952381 | 88 | java |
mapc2020-lfc | mapc2020-lfc-master/test/lfc/agentcontest2020/ScenarioRunSampleTwoTeams.java | package lfc.agentcontest2020;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import org.apache.commons.io.FileUtils;
import org.junit.Before;
import org.junit.Test;
import jacamo.infra.JaCaMoLauncher;
import jason.JasonException;
import massim.Server;
public class ScenarioRunSampleTwoTeams {
@Before
public void cleanUpFolders() throws IOException {
File currentDir = new File("");
String path = currentDir.getAbsolutePath();
ScenarioRunSampleTwoTeams deletefiles = new ScenarioRunSampleTwoTeams();
deletefiles.delete(5, path + "/logs");
deletefiles.delete(4, path + "/log");
deletefiles.delete(5, path + "/replays");
}
public void delete(long nFiles, String directoryFolder) throws IOException {
File folder = new File(directoryFolder);
if(folder.exists()) {
File[] listFiles = folder.listFiles();
Arrays.sort(listFiles);
for ( int i=0; i < listFiles.length - nFiles ; i++ ){
if (!listFiles[i].getName().equals(".keepfolder")) {
// System.out.println(listFiles[i].getName());
listFiles[i].delete();
FileUtils.deleteDirectory(listFiles[i]);
}
}
}
}
@Before
public void setUp() {
new Thread(new Runnable() {
@Override
public void run() {
try {
Server.main(new String[] {"-conf", "conf/SampleTwoTeamsConfig.json", "--monitor"});
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
try {
JaCaMoLauncher.main(new String[] {"lfc-mapc2020-15.jcm"});
} catch (JasonException e) {
System.out.println("Exception: "+e.getMessage());
e.printStackTrace();
}
}
@Test
public void run() {
}
} | 1,681 | 21.72973 | 92 | java |
mapc2020-lfc | mapc2020-lfc-master/test/lfc/agentcontest2020/ScenarioRunSample.java | package lfc.agentcontest2020;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import org.apache.commons.io.FileUtils;
import org.junit.Before;
import org.junit.Test;
import jacamo.infra.JaCaMoLauncher;
import jason.JasonException;
import massim.Server;
public class ScenarioRunSample {
@Before
public void cleanUpFolders() throws IOException {
File currentDir = new File("");
String path = currentDir.getAbsolutePath();
ScenarioRunSample deletefiles = new ScenarioRunSample();
deletefiles.delete(5, path + "/logs");
deletefiles.delete(4, path + "/log");
deletefiles.delete(5, path + "/replays");
}
public void delete(long nFiles, String directoryFolder) throws IOException {
File folder = new File(directoryFolder);
if(folder.exists()) {
File[] listFiles = folder.listFiles();
Arrays.sort(listFiles);
for ( int i=0; i < listFiles.length - nFiles ; i++ ){
if (!listFiles[i].getName().equals(".keepfolder")) {
// System.out.println(listFiles[i].getName());
listFiles[i].delete();
FileUtils.deleteDirectory(listFiles[i]);
}
}
}
}
@Before
public void setUp() {
new Thread(new Runnable() {
@Override
public void run() {
try {
Server.main(new String[] {"-conf", "conf/SampleConfig.json", "--monitor"});
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
try {
JaCaMoLauncher.main(new String[] {"lfc-mapc2020-15.jcm"});
} catch (JasonException e) {
System.out.println("Exception: "+e.getMessage());
e.printStackTrace();
}
}
@Test
public void run() {
}
}
| 1,659 | 18.761905 | 84 | java |
mapc2020-lfc | mapc2020-lfc-master/test/lfc/agentcontest2020/ScenarioRunSampleQualificationRound2.java | package lfc.agentcontest2020;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import org.apache.commons.io.FileUtils;
import org.junit.Before;
import org.junit.Test;
import jacamo.infra.JaCaMoLauncher;
import jason.JasonException;
import massim.Server;
public class ScenarioRunSampleQualificationRound2 {
@Before
public void cleanUpFolders() throws IOException {
File currentDir = new File("");
String path = currentDir.getAbsolutePath();
ScenarioRunSampleQualificationRound2 deletefiles = new ScenarioRunSampleQualificationRound2();
deletefiles.delete(5, path + "/logs");
deletefiles.delete(4, path + "/log");
deletefiles.delete(5, path + "/replays");
}
public void delete(long nFiles, String directoryFolder) throws IOException {
File folder = new File(directoryFolder);
if(folder.exists()) {
File[] listFiles = folder.listFiles();
Arrays.sort(listFiles);
for ( int i=0; i < listFiles.length - nFiles ; i++ ){
if (!listFiles[i].getName().equals(".keepfolder")) {
// System.out.println(listFiles[i].getName());
listFiles[i].delete();
FileUtils.deleteDirectory(listFiles[i]);
}
}
}
}
@Before
public void setUp() {
new Thread(new Runnable() {
@Override
public void run() {
try {
Server.main(new String[] {"-conf", "conf/SampleQualification2.json", "--monitor"});
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
try {
JaCaMoLauncher.main(new String[] {"lfc-mapc2020-50.jcm"});
} catch (JasonException e) {
System.out.println("Exception: "+e.getMessage());
e.printStackTrace();
}
}
@Test
public void run() {
}
}
| 1,724 | 19.535714 | 96 | java |
mapc2020-lfc | mapc2020-lfc-master/test/lfc/agentcontest2020/ScenarioRunSampleSim1.java | package lfc.agentcontest2020;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import org.apache.commons.io.FileUtils;
import org.junit.Before;
import org.junit.Test;
import jacamo.infra.JaCaMoLauncher;
import jason.JasonException;
import massim.Server;
public class ScenarioRunSampleSim1 {
@Before
public void cleanUpFolders() throws IOException {
File currentDir = new File("");
String path = currentDir.getAbsolutePath();
ScenarioRunSampleSim1 deletefiles = new ScenarioRunSampleSim1();
deletefiles.delete(5, path + "/logs");
deletefiles.delete(4, path + "/log");
deletefiles.delete(5, path + "/replays");
}
public void delete(long nFiles, String directoryFolder) throws IOException {
File folder = new File(directoryFolder);
if(folder.exists()) {
File[] listFiles = folder.listFiles();
Arrays.sort(listFiles);
for ( int i=0; i < listFiles.length - nFiles ; i++ ){
if (!listFiles[i].getName().equals(".keepfolder")) {
// System.out.println(listFiles[i].getName());
listFiles[i].delete();
FileUtils.deleteDirectory(listFiles[i]);
}
}
}
}
@Before
public void setUp() {
new Thread(new Runnable() {
@Override
public void run() {
try {
Server.main(new String[] {"-conf", "conf/SampleConfigSim1.json", "--monitor"});
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
try {
JaCaMoLauncher.main(new String[] {"lfc-mapc2020-15.jcm"});
} catch (JasonException e) {
System.out.println("Exception: "+e.getMessage());
e.printStackTrace();
}
}
@Test
public void run() {
}
}
| 1,675 | 18.952381 | 88 | java |
mapc2020-lfc | mapc2020-lfc-master/test/lfc/agentcontest2020/ScenarioRunSampleQualificationRound1.java | package lfc.agentcontest2020;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import org.apache.commons.io.FileUtils;
import org.junit.Before;
import org.junit.Test;
import jacamo.infra.JaCaMoLauncher;
import jason.JasonException;
import massim.Server;
public class ScenarioRunSampleQualificationRound1 {
@Before
public void cleanUpFolders() throws IOException {
File currentDir = new File("");
String path = currentDir.getAbsolutePath();
ScenarioRunSampleQualificationRound1 deletefiles = new ScenarioRunSampleQualificationRound1();
deletefiles.delete(5, path + "/logs");
deletefiles.delete(4, path + "/log");
deletefiles.delete(5, path + "/replays");
}
public void delete(long nFiles, String directoryFolder) throws IOException {
File folder = new File(directoryFolder);
if(folder.exists()) {
File[] listFiles = folder.listFiles();
Arrays.sort(listFiles);
for ( int i=0; i < listFiles.length - nFiles ; i++ ){
if (!listFiles[i].getName().equals(".keepfolder")) {
// System.out.println(listFiles[i].getName());
listFiles[i].delete();
FileUtils.deleteDirectory(listFiles[i]);
}
}
}
}
@Before
public void setUp() {
new Thread(new Runnable() {
@Override
public void run() {
try {
Server.main(new String[] {"-conf", "conf/SampleQualification1.json", "--monitor"});
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
try {
JaCaMoLauncher.main(new String[] {"lfc-mapc2020-15.jcm"});
} catch (JasonException e) {
System.out.println("Exception: "+e.getMessage());
e.printStackTrace();
}
}
@Test
public void run() {
}
}
| 1,724 | 19.535714 | 96 | java |
mapc2020-lfc | mapc2020-lfc-master/test/lfc/agentcontest2020/ScenarioRunContest2_30.java | package lfc.agentcontest2020;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import org.apache.commons.io.FileUtils;
import org.junit.Before;
import org.junit.Test;
import jacamo.infra.JaCaMoLauncher;
import jason.JasonException;
import massim.Server;
public class ScenarioRunContest2_30 {
@Before
public void cleanUpFolders() throws IOException {
File currentDir = new File("");
String path = currentDir.getAbsolutePath();
ScenarioRunContest2_30 deletefiles = new ScenarioRunContest2_30();
deletefiles.delete(5, path + "/logs");
deletefiles.delete(4, path + "/log");
deletefiles.delete(5, path + "/replays");
}
public void delete(long nFiles, String directoryFolder) throws IOException {
File folder = new File(directoryFolder);
if(folder.exists()) {
File[] listFiles = folder.listFiles();
Arrays.sort(listFiles);
for ( int i=0; i < listFiles.length - nFiles ; i++ ){
if (!listFiles[i].getName().equals(".keepfolder")) {
// System.out.println(listFiles[i].getName());
listFiles[i].delete();
FileUtils.deleteDirectory(listFiles[i]);
}
}
}
}
@Before
public void setUp() {
try {
JaCaMoLauncher.main(new String[] {"lfc-mapc2020-30-contest2.jcm"});
} catch (JasonException e) {
System.out.println("Exception: "+e.getMessage());
e.printStackTrace();
}
}
@Test
public void run() {
}
}
| 1,430 | 19.15493 | 77 | java |
mapc2020-lfc | mapc2020-lfc-master/test/lfc/agentcontest2020/ScenarioRunContest1_50.java | package lfc.agentcontest2020;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import org.apache.commons.io.FileUtils;
import org.junit.Before;
import org.junit.Test;
import jacamo.infra.JaCaMoLauncher;
import jason.JasonException;
import massim.Server;
public class ScenarioRunContest1_50 {
@Before
public void cleanUpFolders() throws IOException {
File currentDir = new File("");
String path = currentDir.getAbsolutePath();
ScenarioRunContest1_50 deletefiles = new ScenarioRunContest1_50();
deletefiles.delete(5, path + "/logs");
deletefiles.delete(4, path + "/log");
deletefiles.delete(5, path + "/replays");
}
public void delete(long nFiles, String directoryFolder) throws IOException {
File folder = new File(directoryFolder);
if(folder.exists()) {
File[] listFiles = folder.listFiles();
Arrays.sort(listFiles);
for ( int i=0; i < listFiles.length - nFiles ; i++ ){
if (!listFiles[i].getName().equals(".keepfolder")) {
// System.out.println(listFiles[i].getName());
listFiles[i].delete();
FileUtils.deleteDirectory(listFiles[i]);
}
}
}
}
@Before
public void setUp() {
try {
JaCaMoLauncher.main(new String[] {"lfc-mapc2020-50-contest1.jcm"});
} catch (JasonException e) {
System.out.println("Exception: "+e.getMessage());
e.printStackTrace();
}
}
@Test
public void run() {
}
}
| 1,430 | 19.15493 | 77 | java |
mapc2020-lfc | mapc2020-lfc-master/test/lfc/agentcontest2020/ScenarioRunContest1_30.java | package lfc.agentcontest2020;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import org.apache.commons.io.FileUtils;
import org.junit.Before;
import org.junit.Test;
import jacamo.infra.JaCaMoLauncher;
import jason.JasonException;
import massim.Server;
public class ScenarioRunContest1_30 {
@Before
public void cleanUpFolders() throws IOException {
File currentDir = new File("");
String path = currentDir.getAbsolutePath();
ScenarioRunContest1_30 deletefiles = new ScenarioRunContest1_30();
deletefiles.delete(5, path + "/logs");
deletefiles.delete(4, path + "/log");
deletefiles.delete(5, path + "/replays");
}
public void delete(long nFiles, String directoryFolder) throws IOException {
File folder = new File(directoryFolder);
if(folder.exists()) {
File[] listFiles = folder.listFiles();
Arrays.sort(listFiles);
for ( int i=0; i < listFiles.length - nFiles ; i++ ){
if (!listFiles[i].getName().equals(".keepfolder")) {
// System.out.println(listFiles[i].getName());
listFiles[i].delete();
FileUtils.deleteDirectory(listFiles[i]);
}
}
}
}
@Before
public void setUp() {
try {
JaCaMoLauncher.main(new String[] {"lfc-mapc2020-30-contest1.jcm"});
} catch (JasonException e) {
System.out.println("Exception: "+e.getMessage());
e.printStackTrace();
}
}
@Test
public void run() {
}
}
| 1,430 | 19.15493 | 77 | java |
mapc2020-lfc | mapc2020-lfc-master/test/lfc/agentcontest2020/ScenarioRunSampleTwoTeams50.java | package lfc.agentcontest2020;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import org.apache.commons.io.FileUtils;
import org.junit.Before;
import org.junit.Test;
import jacamo.infra.JaCaMoLauncher;
import jason.JasonException;
import massim.Server;
public class ScenarioRunSampleTwoTeams50 {
@Before
public void cleanUpFolders() throws IOException {
File currentDir = new File("");
String path = currentDir.getAbsolutePath();
ScenarioRunSampleTwoTeams50 deletefiles = new ScenarioRunSampleTwoTeams50();
deletefiles.delete(5, path + "/logs");
deletefiles.delete(4, path + "/log");
deletefiles.delete(5, path + "/replays");
}
public void delete(long nFiles, String directoryFolder) throws IOException {
File folder = new File(directoryFolder);
if(folder.exists()) {
File[] listFiles = folder.listFiles();
Arrays.sort(listFiles);
for ( int i=0; i < listFiles.length - nFiles ; i++ ){
if (!listFiles[i].getName().equals(".keepfolder")) {
// System.out.println(listFiles[i].getName());
listFiles[i].delete();
FileUtils.deleteDirectory(listFiles[i]);
}
}
}
}
@Before
public void setUp() {
new Thread(new Runnable() {
@Override
public void run() {
try {
Server.main(new String[] {"-conf", "conf/SampleTwoTeamsConfig50.json", "--monitor"});
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
try {
JaCaMoLauncher.main(new String[] {"lfc-mapc2020-50.jcm"});
} catch (JasonException e) {
System.out.println("Exception: "+e.getMessage());
e.printStackTrace();
}
}
@Test
public void run() {
}
} | 1,689 | 21.837838 | 94 | java |
mapc2020-lfc | mapc2020-lfc-master/test/lfc/agentcontest2020/ScenarioRunSampleTwoTeamsTeamC.java | package lfc.agentcontest2020;
import org.junit.Before;
import org.junit.Test;
import jacamo.infra.JaCaMoLauncher;
import jason.JasonException;
public class ScenarioRunSampleTwoTeamsTeamC {
@Before
public void setUp() {
try {
JaCaMoLauncher.main(new String[] {"lfc-mapc2020-15-TeamC.jcm"});
} catch (JasonException e) {
System.out.println("Exception: "+e.getMessage());
e.printStackTrace();
}
}
@Test
public void run() {
}
} | 457 | 17.32 | 67 | java |
self | self-master/vs2015/self_instance_android/src/com/ibm/self/SelfMain.java |
package com.self_instance_android;
import android.app.Activity;
import android.widget.TextView;
import android.os.Bundle;
public class SelfMain extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
TextView tv = new TextView(this);
String[] args = { "self_instance", "-s", "/sdcard/self/etc/", "-i", "/sdcard/self/", "-f", "0" };
System.loadLibrary("self_android");
if (IsRunning() == 0) {
if (Start(args) == 0)
tv.setText("Self running...");
else
tv.setText("Failed to start self...");
} else
tv.setText("Self already running...");
setContentView(tv);
}
@Override
public void onDestroy() {
super.onDestroy();
if (IsRunning() != 0)
Stop();
}
public native int Start(String[] a_Args);
public native int IsRunning();
public native int Stop();
}
| 913 | 20.255814 | 99 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/video/KalmanFilter.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.video;
import org.opencv.core.Mat;
// C++: class KalmanFilter
//javadoc: KalmanFilter
public class KalmanFilter {
protected final long nativeObj;
protected KalmanFilter(long addr) { nativeObj = addr; }
//
// C++: KalmanFilter(int dynamParams, int measureParams, int controlParams = 0, int type = CV_32F)
//
//javadoc: KalmanFilter::KalmanFilter(dynamParams, measureParams, controlParams, type)
public KalmanFilter(int dynamParams, int measureParams, int controlParams, int type)
{
nativeObj = KalmanFilter_0(dynamParams, measureParams, controlParams, type);
return;
}
//javadoc: KalmanFilter::KalmanFilter(dynamParams, measureParams)
public KalmanFilter(int dynamParams, int measureParams)
{
nativeObj = KalmanFilter_1(dynamParams, measureParams);
return;
}
//
// C++: KalmanFilter()
//
//javadoc: KalmanFilter::KalmanFilter()
public KalmanFilter()
{
nativeObj = KalmanFilter_2();
return;
}
//
// C++: Mat correct(Mat measurement)
//
//javadoc: KalmanFilter::correct(measurement)
public Mat correct(Mat measurement)
{
Mat retVal = new Mat(correct_0(nativeObj, measurement.nativeObj));
return retVal;
}
//
// C++: Mat predict(Mat control = Mat())
//
//javadoc: KalmanFilter::predict(control)
public Mat predict(Mat control)
{
Mat retVal = new Mat(predict_0(nativeObj, control.nativeObj));
return retVal;
}
//javadoc: KalmanFilter::predict()
public Mat predict()
{
Mat retVal = new Mat(predict_1(nativeObj));
return retVal;
}
//
// C++: Mat KalmanFilter::statePre
//
//javadoc: KalmanFilter::get_statePre()
public Mat get_statePre()
{
Mat retVal = new Mat(get_statePre_0(nativeObj));
return retVal;
}
//
// C++: void KalmanFilter::statePre
//
//javadoc: KalmanFilter::set_statePre(statePre)
public void set_statePre(Mat statePre)
{
set_statePre_0(nativeObj, statePre.nativeObj);
return;
}
//
// C++: Mat KalmanFilter::statePost
//
//javadoc: KalmanFilter::get_statePost()
public Mat get_statePost()
{
Mat retVal = new Mat(get_statePost_0(nativeObj));
return retVal;
}
//
// C++: void KalmanFilter::statePost
//
//javadoc: KalmanFilter::set_statePost(statePost)
public void set_statePost(Mat statePost)
{
set_statePost_0(nativeObj, statePost.nativeObj);
return;
}
//
// C++: Mat KalmanFilter::transitionMatrix
//
//javadoc: KalmanFilter::get_transitionMatrix()
public Mat get_transitionMatrix()
{
Mat retVal = new Mat(get_transitionMatrix_0(nativeObj));
return retVal;
}
//
// C++: void KalmanFilter::transitionMatrix
//
//javadoc: KalmanFilter::set_transitionMatrix(transitionMatrix)
public void set_transitionMatrix(Mat transitionMatrix)
{
set_transitionMatrix_0(nativeObj, transitionMatrix.nativeObj);
return;
}
//
// C++: Mat KalmanFilter::controlMatrix
//
//javadoc: KalmanFilter::get_controlMatrix()
public Mat get_controlMatrix()
{
Mat retVal = new Mat(get_controlMatrix_0(nativeObj));
return retVal;
}
//
// C++: void KalmanFilter::controlMatrix
//
//javadoc: KalmanFilter::set_controlMatrix(controlMatrix)
public void set_controlMatrix(Mat controlMatrix)
{
set_controlMatrix_0(nativeObj, controlMatrix.nativeObj);
return;
}
//
// C++: Mat KalmanFilter::measurementMatrix
//
//javadoc: KalmanFilter::get_measurementMatrix()
public Mat get_measurementMatrix()
{
Mat retVal = new Mat(get_measurementMatrix_0(nativeObj));
return retVal;
}
//
// C++: void KalmanFilter::measurementMatrix
//
//javadoc: KalmanFilter::set_measurementMatrix(measurementMatrix)
public void set_measurementMatrix(Mat measurementMatrix)
{
set_measurementMatrix_0(nativeObj, measurementMatrix.nativeObj);
return;
}
//
// C++: Mat KalmanFilter::processNoiseCov
//
//javadoc: KalmanFilter::get_processNoiseCov()
public Mat get_processNoiseCov()
{
Mat retVal = new Mat(get_processNoiseCov_0(nativeObj));
return retVal;
}
//
// C++: void KalmanFilter::processNoiseCov
//
//javadoc: KalmanFilter::set_processNoiseCov(processNoiseCov)
public void set_processNoiseCov(Mat processNoiseCov)
{
set_processNoiseCov_0(nativeObj, processNoiseCov.nativeObj);
return;
}
//
// C++: Mat KalmanFilter::measurementNoiseCov
//
//javadoc: KalmanFilter::get_measurementNoiseCov()
public Mat get_measurementNoiseCov()
{
Mat retVal = new Mat(get_measurementNoiseCov_0(nativeObj));
return retVal;
}
//
// C++: void KalmanFilter::measurementNoiseCov
//
//javadoc: KalmanFilter::set_measurementNoiseCov(measurementNoiseCov)
public void set_measurementNoiseCov(Mat measurementNoiseCov)
{
set_measurementNoiseCov_0(nativeObj, measurementNoiseCov.nativeObj);
return;
}
//
// C++: Mat KalmanFilter::errorCovPre
//
//javadoc: KalmanFilter::get_errorCovPre()
public Mat get_errorCovPre()
{
Mat retVal = new Mat(get_errorCovPre_0(nativeObj));
return retVal;
}
//
// C++: void KalmanFilter::errorCovPre
//
//javadoc: KalmanFilter::set_errorCovPre(errorCovPre)
public void set_errorCovPre(Mat errorCovPre)
{
set_errorCovPre_0(nativeObj, errorCovPre.nativeObj);
return;
}
//
// C++: Mat KalmanFilter::gain
//
//javadoc: KalmanFilter::get_gain()
public Mat get_gain()
{
Mat retVal = new Mat(get_gain_0(nativeObj));
return retVal;
}
//
// C++: void KalmanFilter::gain
//
//javadoc: KalmanFilter::set_gain(gain)
public void set_gain(Mat gain)
{
set_gain_0(nativeObj, gain.nativeObj);
return;
}
//
// C++: Mat KalmanFilter::errorCovPost
//
//javadoc: KalmanFilter::get_errorCovPost()
public Mat get_errorCovPost()
{
Mat retVal = new Mat(get_errorCovPost_0(nativeObj));
return retVal;
}
//
// C++: void KalmanFilter::errorCovPost
//
//javadoc: KalmanFilter::set_errorCovPost(errorCovPost)
public void set_errorCovPost(Mat errorCovPost)
{
set_errorCovPost_0(nativeObj, errorCovPost.nativeObj);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: KalmanFilter(int dynamParams, int measureParams, int controlParams = 0, int type = CV_32F)
private static native long KalmanFilter_0(int dynamParams, int measureParams, int controlParams, int type);
private static native long KalmanFilter_1(int dynamParams, int measureParams);
// C++: KalmanFilter()
private static native long KalmanFilter_2();
// C++: Mat correct(Mat measurement)
private static native long correct_0(long nativeObj, long measurement_nativeObj);
// C++: Mat predict(Mat control = Mat())
private static native long predict_0(long nativeObj, long control_nativeObj);
private static native long predict_1(long nativeObj);
// C++: Mat KalmanFilter::statePre
private static native long get_statePre_0(long nativeObj);
// C++: void KalmanFilter::statePre
private static native void set_statePre_0(long nativeObj, long statePre_nativeObj);
// C++: Mat KalmanFilter::statePost
private static native long get_statePost_0(long nativeObj);
// C++: void KalmanFilter::statePost
private static native void set_statePost_0(long nativeObj, long statePost_nativeObj);
// C++: Mat KalmanFilter::transitionMatrix
private static native long get_transitionMatrix_0(long nativeObj);
// C++: void KalmanFilter::transitionMatrix
private static native void set_transitionMatrix_0(long nativeObj, long transitionMatrix_nativeObj);
// C++: Mat KalmanFilter::controlMatrix
private static native long get_controlMatrix_0(long nativeObj);
// C++: void KalmanFilter::controlMatrix
private static native void set_controlMatrix_0(long nativeObj, long controlMatrix_nativeObj);
// C++: Mat KalmanFilter::measurementMatrix
private static native long get_measurementMatrix_0(long nativeObj);
// C++: void KalmanFilter::measurementMatrix
private static native void set_measurementMatrix_0(long nativeObj, long measurementMatrix_nativeObj);
// C++: Mat KalmanFilter::processNoiseCov
private static native long get_processNoiseCov_0(long nativeObj);
// C++: void KalmanFilter::processNoiseCov
private static native void set_processNoiseCov_0(long nativeObj, long processNoiseCov_nativeObj);
// C++: Mat KalmanFilter::measurementNoiseCov
private static native long get_measurementNoiseCov_0(long nativeObj);
// C++: void KalmanFilter::measurementNoiseCov
private static native void set_measurementNoiseCov_0(long nativeObj, long measurementNoiseCov_nativeObj);
// C++: Mat KalmanFilter::errorCovPre
private static native long get_errorCovPre_0(long nativeObj);
// C++: void KalmanFilter::errorCovPre
private static native void set_errorCovPre_0(long nativeObj, long errorCovPre_nativeObj);
// C++: Mat KalmanFilter::gain
private static native long get_gain_0(long nativeObj);
// C++: void KalmanFilter::gain
private static native void set_gain_0(long nativeObj, long gain_nativeObj);
// C++: Mat KalmanFilter::errorCovPost
private static native long get_errorCovPost_0(long nativeObj);
// C++: void KalmanFilter::errorCovPost
private static native void set_errorCovPost_0(long nativeObj, long errorCovPost_nativeObj);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 10,765 | 22.609649 | 111 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/video/DualTVL1OpticalFlow.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.video;
// C++: class DualTVL1OpticalFlow
//javadoc: DualTVL1OpticalFlow
public class DualTVL1OpticalFlow extends DenseOpticalFlow {
protected DualTVL1OpticalFlow(long addr) { super(addr); }
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 481 | 16.851852 | 61 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/video/BackgroundSubtractorKNN.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.video;
// C++: class BackgroundSubtractorKNN
//javadoc: BackgroundSubtractorKNN
public class BackgroundSubtractorKNN extends BackgroundSubtractor {
protected BackgroundSubtractorKNN(long addr) { super(addr); }
//
// C++: bool getDetectShadows()
//
//javadoc: BackgroundSubtractorKNN::getDetectShadows()
public boolean getDetectShadows()
{
boolean retVal = getDetectShadows_0(nativeObj);
return retVal;
}
//
// C++: double getDist2Threshold()
//
//javadoc: BackgroundSubtractorKNN::getDist2Threshold()
public double getDist2Threshold()
{
double retVal = getDist2Threshold_0(nativeObj);
return retVal;
}
//
// C++: double getShadowThreshold()
//
//javadoc: BackgroundSubtractorKNN::getShadowThreshold()
public double getShadowThreshold()
{
double retVal = getShadowThreshold_0(nativeObj);
return retVal;
}
//
// C++: int getHistory()
//
//javadoc: BackgroundSubtractorKNN::getHistory()
public int getHistory()
{
int retVal = getHistory_0(nativeObj);
return retVal;
}
//
// C++: int getNSamples()
//
//javadoc: BackgroundSubtractorKNN::getNSamples()
public int getNSamples()
{
int retVal = getNSamples_0(nativeObj);
return retVal;
}
//
// C++: int getShadowValue()
//
//javadoc: BackgroundSubtractorKNN::getShadowValue()
public int getShadowValue()
{
int retVal = getShadowValue_0(nativeObj);
return retVal;
}
//
// C++: int getkNNSamples()
//
//javadoc: BackgroundSubtractorKNN::getkNNSamples()
public int getkNNSamples()
{
int retVal = getkNNSamples_0(nativeObj);
return retVal;
}
//
// C++: void setDetectShadows(bool detectShadows)
//
//javadoc: BackgroundSubtractorKNN::setDetectShadows(detectShadows)
public void setDetectShadows(boolean detectShadows)
{
setDetectShadows_0(nativeObj, detectShadows);
return;
}
//
// C++: void setDist2Threshold(double _dist2Threshold)
//
//javadoc: BackgroundSubtractorKNN::setDist2Threshold(_dist2Threshold)
public void setDist2Threshold(double _dist2Threshold)
{
setDist2Threshold_0(nativeObj, _dist2Threshold);
return;
}
//
// C++: void setHistory(int history)
//
//javadoc: BackgroundSubtractorKNN::setHistory(history)
public void setHistory(int history)
{
setHistory_0(nativeObj, history);
return;
}
//
// C++: void setNSamples(int _nN)
//
//javadoc: BackgroundSubtractorKNN::setNSamples(_nN)
public void setNSamples(int _nN)
{
setNSamples_0(nativeObj, _nN);
return;
}
//
// C++: void setShadowThreshold(double threshold)
//
//javadoc: BackgroundSubtractorKNN::setShadowThreshold(threshold)
public void setShadowThreshold(double threshold)
{
setShadowThreshold_0(nativeObj, threshold);
return;
}
//
// C++: void setShadowValue(int value)
//
//javadoc: BackgroundSubtractorKNN::setShadowValue(value)
public void setShadowValue(int value)
{
setShadowValue_0(nativeObj, value);
return;
}
//
// C++: void setkNNSamples(int _nkNN)
//
//javadoc: BackgroundSubtractorKNN::setkNNSamples(_nkNN)
public void setkNNSamples(int _nkNN)
{
setkNNSamples_0(nativeObj, _nkNN);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: bool getDetectShadows()
private static native boolean getDetectShadows_0(long nativeObj);
// C++: double getDist2Threshold()
private static native double getDist2Threshold_0(long nativeObj);
// C++: double getShadowThreshold()
private static native double getShadowThreshold_0(long nativeObj);
// C++: int getHistory()
private static native int getHistory_0(long nativeObj);
// C++: int getNSamples()
private static native int getNSamples_0(long nativeObj);
// C++: int getShadowValue()
private static native int getShadowValue_0(long nativeObj);
// C++: int getkNNSamples()
private static native int getkNNSamples_0(long nativeObj);
// C++: void setDetectShadows(bool detectShadows)
private static native void setDetectShadows_0(long nativeObj, boolean detectShadows);
// C++: void setDist2Threshold(double _dist2Threshold)
private static native void setDist2Threshold_0(long nativeObj, double _dist2Threshold);
// C++: void setHistory(int history)
private static native void setHistory_0(long nativeObj, int history);
// C++: void setNSamples(int _nN)
private static native void setNSamples_0(long nativeObj, int _nN);
// C++: void setShadowThreshold(double threshold)
private static native void setShadowThreshold_0(long nativeObj, double threshold);
// C++: void setShadowValue(int value)
private static native void setShadowValue_0(long nativeObj, int value);
// C++: void setkNNSamples(int _nkNN)
private static native void setkNNSamples_0(long nativeObj, int _nkNN);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 5,763 | 20.750943 | 91 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/video/Video.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.video;
import java.util.ArrayList;
import java.util.List;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.MatOfFloat;
import org.opencv.core.MatOfPoint2f;
import org.opencv.core.Rect;
import org.opencv.core.RotatedRect;
import org.opencv.core.Size;
import org.opencv.core.TermCriteria;
import org.opencv.utils.Converters;
public class Video {
private static final int
CV_LKFLOW_INITIAL_GUESSES = 4,
CV_LKFLOW_GET_MIN_EIGENVALS = 8;
public static final int
OPTFLOW_USE_INITIAL_FLOW = 4,
OPTFLOW_LK_GET_MIN_EIGENVALS = 8,
OPTFLOW_FARNEBACK_GAUSSIAN = 256,
MOTION_TRANSLATION = 0,
MOTION_EUCLIDEAN = 1,
MOTION_AFFINE = 2,
MOTION_HOMOGRAPHY = 3;
//
// C++: Mat estimateRigidTransform(Mat src, Mat dst, bool fullAffine)
//
//javadoc: estimateRigidTransform(src, dst, fullAffine)
public static Mat estimateRigidTransform(Mat src, Mat dst, boolean fullAffine)
{
Mat retVal = new Mat(estimateRigidTransform_0(src.nativeObj, dst.nativeObj, fullAffine));
return retVal;
}
//
// C++: Ptr_BackgroundSubtractorKNN createBackgroundSubtractorKNN(int history = 500, double dist2Threshold = 400.0, bool detectShadows = true)
//
//javadoc: createBackgroundSubtractorKNN(history, dist2Threshold, detectShadows)
public static BackgroundSubtractorKNN createBackgroundSubtractorKNN(int history, double dist2Threshold, boolean detectShadows)
{
BackgroundSubtractorKNN retVal = new BackgroundSubtractorKNN(createBackgroundSubtractorKNN_0(history, dist2Threshold, detectShadows));
return retVal;
}
//javadoc: createBackgroundSubtractorKNN()
public static BackgroundSubtractorKNN createBackgroundSubtractorKNN()
{
BackgroundSubtractorKNN retVal = new BackgroundSubtractorKNN(createBackgroundSubtractorKNN_1());
return retVal;
}
//
// C++: Ptr_BackgroundSubtractorMOG2 createBackgroundSubtractorMOG2(int history = 500, double varThreshold = 16, bool detectShadows = true)
//
//javadoc: createBackgroundSubtractorMOG2(history, varThreshold, detectShadows)
public static BackgroundSubtractorMOG2 createBackgroundSubtractorMOG2(int history, double varThreshold, boolean detectShadows)
{
BackgroundSubtractorMOG2 retVal = new BackgroundSubtractorMOG2(createBackgroundSubtractorMOG2_0(history, varThreshold, detectShadows));
return retVal;
}
//javadoc: createBackgroundSubtractorMOG2()
public static BackgroundSubtractorMOG2 createBackgroundSubtractorMOG2()
{
BackgroundSubtractorMOG2 retVal = new BackgroundSubtractorMOG2(createBackgroundSubtractorMOG2_1());
return retVal;
}
//
// C++: Ptr_DualTVL1OpticalFlow createOptFlow_DualTVL1()
//
//javadoc: createOptFlow_DualTVL1()
public static DualTVL1OpticalFlow createOptFlow_DualTVL1()
{
DualTVL1OpticalFlow retVal = new DualTVL1OpticalFlow(createOptFlow_DualTVL1_0());
return retVal;
}
//
// C++: RotatedRect CamShift(Mat probImage, Rect& window, TermCriteria criteria)
//
//javadoc: CamShift(probImage, window, criteria)
public static RotatedRect CamShift(Mat probImage, Rect window, TermCriteria criteria)
{
double[] window_out = new double[4];
RotatedRect retVal = new RotatedRect(CamShift_0(probImage.nativeObj, window.x, window.y, window.width, window.height, window_out, criteria.type, criteria.maxCount, criteria.epsilon));
if(window!=null){ window.x = (int)window_out[0]; window.y = (int)window_out[1]; window.width = (int)window_out[2]; window.height = (int)window_out[3]; }
return retVal;
}
//
// C++: double findTransformECC(Mat templateImage, Mat inputImage, Mat& warpMatrix, int motionType = MOTION_AFFINE, TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 50, 0.001), Mat inputMask = Mat())
//
//javadoc: findTransformECC(templateImage, inputImage, warpMatrix, motionType, criteria, inputMask)
public static double findTransformECC(Mat templateImage, Mat inputImage, Mat warpMatrix, int motionType, TermCriteria criteria, Mat inputMask)
{
double retVal = findTransformECC_0(templateImage.nativeObj, inputImage.nativeObj, warpMatrix.nativeObj, motionType, criteria.type, criteria.maxCount, criteria.epsilon, inputMask.nativeObj);
return retVal;
}
//javadoc: findTransformECC(templateImage, inputImage, warpMatrix, motionType)
public static double findTransformECC(Mat templateImage, Mat inputImage, Mat warpMatrix, int motionType)
{
double retVal = findTransformECC_1(templateImage.nativeObj, inputImage.nativeObj, warpMatrix.nativeObj, motionType);
return retVal;
}
//javadoc: findTransformECC(templateImage, inputImage, warpMatrix)
public static double findTransformECC(Mat templateImage, Mat inputImage, Mat warpMatrix)
{
double retVal = findTransformECC_2(templateImage.nativeObj, inputImage.nativeObj, warpMatrix.nativeObj);
return retVal;
}
//
// C++: int buildOpticalFlowPyramid(Mat img, vector_Mat& pyramid, Size winSize, int maxLevel, bool withDerivatives = true, int pyrBorder = BORDER_REFLECT_101, int derivBorder = BORDER_CONSTANT, bool tryReuseInputImage = true)
//
//javadoc: buildOpticalFlowPyramid(img, pyramid, winSize, maxLevel, withDerivatives, pyrBorder, derivBorder, tryReuseInputImage)
public static int buildOpticalFlowPyramid(Mat img, List<Mat> pyramid, Size winSize, int maxLevel, boolean withDerivatives, int pyrBorder, int derivBorder, boolean tryReuseInputImage)
{
Mat pyramid_mat = new Mat();
int retVal = buildOpticalFlowPyramid_0(img.nativeObj, pyramid_mat.nativeObj, winSize.width, winSize.height, maxLevel, withDerivatives, pyrBorder, derivBorder, tryReuseInputImage);
Converters.Mat_to_vector_Mat(pyramid_mat, pyramid);
pyramid_mat.release();
return retVal;
}
//javadoc: buildOpticalFlowPyramid(img, pyramid, winSize, maxLevel)
public static int buildOpticalFlowPyramid(Mat img, List<Mat> pyramid, Size winSize, int maxLevel)
{
Mat pyramid_mat = new Mat();
int retVal = buildOpticalFlowPyramid_1(img.nativeObj, pyramid_mat.nativeObj, winSize.width, winSize.height, maxLevel);
Converters.Mat_to_vector_Mat(pyramid_mat, pyramid);
pyramid_mat.release();
return retVal;
}
//
// C++: int meanShift(Mat probImage, Rect& window, TermCriteria criteria)
//
//javadoc: meanShift(probImage, window, criteria)
public static int meanShift(Mat probImage, Rect window, TermCriteria criteria)
{
double[] window_out = new double[4];
int retVal = meanShift_0(probImage.nativeObj, window.x, window.y, window.width, window.height, window_out, criteria.type, criteria.maxCount, criteria.epsilon);
if(window!=null){ window.x = (int)window_out[0]; window.y = (int)window_out[1]; window.width = (int)window_out[2]; window.height = (int)window_out[3]; }
return retVal;
}
//
// C++: void calcOpticalFlowFarneback(Mat prev, Mat next, Mat& flow, double pyr_scale, int levels, int winsize, int iterations, int poly_n, double poly_sigma, int flags)
//
//javadoc: calcOpticalFlowFarneback(prev, next, flow, pyr_scale, levels, winsize, iterations, poly_n, poly_sigma, flags)
public static void calcOpticalFlowFarneback(Mat prev, Mat next, Mat flow, double pyr_scale, int levels, int winsize, int iterations, int poly_n, double poly_sigma, int flags)
{
calcOpticalFlowFarneback_0(prev.nativeObj, next.nativeObj, flow.nativeObj, pyr_scale, levels, winsize, iterations, poly_n, poly_sigma, flags);
return;
}
//
// C++: void calcOpticalFlowPyrLK(Mat prevImg, Mat nextImg, vector_Point2f prevPts, vector_Point2f& nextPts, vector_uchar& status, vector_float& err, Size winSize = Size(21,21), int maxLevel = 3, TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01), int flags = 0, double minEigThreshold = 1e-4)
//
//javadoc: calcOpticalFlowPyrLK(prevImg, nextImg, prevPts, nextPts, status, err, winSize, maxLevel, criteria, flags, minEigThreshold)
public static void calcOpticalFlowPyrLK(Mat prevImg, Mat nextImg, MatOfPoint2f prevPts, MatOfPoint2f nextPts, MatOfByte status, MatOfFloat err, Size winSize, int maxLevel, TermCriteria criteria, int flags, double minEigThreshold)
{
Mat prevPts_mat = prevPts;
Mat nextPts_mat = nextPts;
Mat status_mat = status;
Mat err_mat = err;
calcOpticalFlowPyrLK_0(prevImg.nativeObj, nextImg.nativeObj, prevPts_mat.nativeObj, nextPts_mat.nativeObj, status_mat.nativeObj, err_mat.nativeObj, winSize.width, winSize.height, maxLevel, criteria.type, criteria.maxCount, criteria.epsilon, flags, minEigThreshold);
return;
}
//javadoc: calcOpticalFlowPyrLK(prevImg, nextImg, prevPts, nextPts, status, err, winSize, maxLevel)
public static void calcOpticalFlowPyrLK(Mat prevImg, Mat nextImg, MatOfPoint2f prevPts, MatOfPoint2f nextPts, MatOfByte status, MatOfFloat err, Size winSize, int maxLevel)
{
Mat prevPts_mat = prevPts;
Mat nextPts_mat = nextPts;
Mat status_mat = status;
Mat err_mat = err;
calcOpticalFlowPyrLK_1(prevImg.nativeObj, nextImg.nativeObj, prevPts_mat.nativeObj, nextPts_mat.nativeObj, status_mat.nativeObj, err_mat.nativeObj, winSize.width, winSize.height, maxLevel);
return;
}
//javadoc: calcOpticalFlowPyrLK(prevImg, nextImg, prevPts, nextPts, status, err)
public static void calcOpticalFlowPyrLK(Mat prevImg, Mat nextImg, MatOfPoint2f prevPts, MatOfPoint2f nextPts, MatOfByte status, MatOfFloat err)
{
Mat prevPts_mat = prevPts;
Mat nextPts_mat = nextPts;
Mat status_mat = status;
Mat err_mat = err;
calcOpticalFlowPyrLK_2(prevImg.nativeObj, nextImg.nativeObj, prevPts_mat.nativeObj, nextPts_mat.nativeObj, status_mat.nativeObj, err_mat.nativeObj);
return;
}
// C++: Mat estimateRigidTransform(Mat src, Mat dst, bool fullAffine)
private static native long estimateRigidTransform_0(long src_nativeObj, long dst_nativeObj, boolean fullAffine);
// C++: Ptr_BackgroundSubtractorKNN createBackgroundSubtractorKNN(int history = 500, double dist2Threshold = 400.0, bool detectShadows = true)
private static native long createBackgroundSubtractorKNN_0(int history, double dist2Threshold, boolean detectShadows);
private static native long createBackgroundSubtractorKNN_1();
// C++: Ptr_BackgroundSubtractorMOG2 createBackgroundSubtractorMOG2(int history = 500, double varThreshold = 16, bool detectShadows = true)
private static native long createBackgroundSubtractorMOG2_0(int history, double varThreshold, boolean detectShadows);
private static native long createBackgroundSubtractorMOG2_1();
// C++: Ptr_DualTVL1OpticalFlow createOptFlow_DualTVL1()
private static native long createOptFlow_DualTVL1_0();
// C++: RotatedRect CamShift(Mat probImage, Rect& window, TermCriteria criteria)
private static native double[] CamShift_0(long probImage_nativeObj, int window_x, int window_y, int window_width, int window_height, double[] window_out, int criteria_type, int criteria_maxCount, double criteria_epsilon);
// C++: double findTransformECC(Mat templateImage, Mat inputImage, Mat& warpMatrix, int motionType = MOTION_AFFINE, TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 50, 0.001), Mat inputMask = Mat())
private static native double findTransformECC_0(long templateImage_nativeObj, long inputImage_nativeObj, long warpMatrix_nativeObj, int motionType, int criteria_type, int criteria_maxCount, double criteria_epsilon, long inputMask_nativeObj);
private static native double findTransformECC_1(long templateImage_nativeObj, long inputImage_nativeObj, long warpMatrix_nativeObj, int motionType);
private static native double findTransformECC_2(long templateImage_nativeObj, long inputImage_nativeObj, long warpMatrix_nativeObj);
// C++: int buildOpticalFlowPyramid(Mat img, vector_Mat& pyramid, Size winSize, int maxLevel, bool withDerivatives = true, int pyrBorder = BORDER_REFLECT_101, int derivBorder = BORDER_CONSTANT, bool tryReuseInputImage = true)
private static native int buildOpticalFlowPyramid_0(long img_nativeObj, long pyramid_mat_nativeObj, double winSize_width, double winSize_height, int maxLevel, boolean withDerivatives, int pyrBorder, int derivBorder, boolean tryReuseInputImage);
private static native int buildOpticalFlowPyramid_1(long img_nativeObj, long pyramid_mat_nativeObj, double winSize_width, double winSize_height, int maxLevel);
// C++: int meanShift(Mat probImage, Rect& window, TermCriteria criteria)
private static native int meanShift_0(long probImage_nativeObj, int window_x, int window_y, int window_width, int window_height, double[] window_out, int criteria_type, int criteria_maxCount, double criteria_epsilon);
// C++: void calcOpticalFlowFarneback(Mat prev, Mat next, Mat& flow, double pyr_scale, int levels, int winsize, int iterations, int poly_n, double poly_sigma, int flags)
private static native void calcOpticalFlowFarneback_0(long prev_nativeObj, long next_nativeObj, long flow_nativeObj, double pyr_scale, int levels, int winsize, int iterations, int poly_n, double poly_sigma, int flags);
// C++: void calcOpticalFlowPyrLK(Mat prevImg, Mat nextImg, vector_Point2f prevPts, vector_Point2f& nextPts, vector_uchar& status, vector_float& err, Size winSize = Size(21,21), int maxLevel = 3, TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01), int flags = 0, double minEigThreshold = 1e-4)
private static native void calcOpticalFlowPyrLK_0(long prevImg_nativeObj, long nextImg_nativeObj, long prevPts_mat_nativeObj, long nextPts_mat_nativeObj, long status_mat_nativeObj, long err_mat_nativeObj, double winSize_width, double winSize_height, int maxLevel, int criteria_type, int criteria_maxCount, double criteria_epsilon, int flags, double minEigThreshold);
private static native void calcOpticalFlowPyrLK_1(long prevImg_nativeObj, long nextImg_nativeObj, long prevPts_mat_nativeObj, long nextPts_mat_nativeObj, long status_mat_nativeObj, long err_mat_nativeObj, double winSize_width, double winSize_height, int maxLevel);
private static native void calcOpticalFlowPyrLK_2(long prevImg_nativeObj, long nextImg_nativeObj, long prevPts_mat_nativeObj, long nextPts_mat_nativeObj, long status_mat_nativeObj, long err_mat_nativeObj);
}
| 15,138 | 51.203448 | 370 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/video/DenseOpticalFlow.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.video;
import org.opencv.core.Algorithm;
import org.opencv.core.Mat;
// C++: class DenseOpticalFlow
//javadoc: DenseOpticalFlow
public class DenseOpticalFlow extends Algorithm {
protected DenseOpticalFlow(long addr) { super(addr); }
//
// C++: void calc(Mat I0, Mat I1, Mat& flow)
//
//javadoc: DenseOpticalFlow::calc(I0, I1, flow)
public void calc(Mat I0, Mat I1, Mat flow)
{
calc_0(nativeObj, I0.nativeObj, I1.nativeObj, flow.nativeObj);
return;
}
//
// C++: void collectGarbage()
//
//javadoc: DenseOpticalFlow::collectGarbage()
public void collectGarbage()
{
collectGarbage_0(nativeObj);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: void calc(Mat I0, Mat I1, Mat& flow)
private static native void calc_0(long nativeObj, long I0_nativeObj, long I1_nativeObj, long flow_nativeObj);
// C++: void collectGarbage()
private static native void collectGarbage_0(long nativeObj);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 1,292 | 19.854839 | 113 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/video/BackgroundSubtractorMOG2.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.video;
// C++: class BackgroundSubtractorMOG2
//javadoc: BackgroundSubtractorMOG2
public class BackgroundSubtractorMOG2 extends BackgroundSubtractor {
protected BackgroundSubtractorMOG2(long addr) { super(addr); }
//
// C++: bool getDetectShadows()
//
//javadoc: BackgroundSubtractorMOG2::getDetectShadows()
public boolean getDetectShadows()
{
boolean retVal = getDetectShadows_0(nativeObj);
return retVal;
}
//
// C++: double getBackgroundRatio()
//
//javadoc: BackgroundSubtractorMOG2::getBackgroundRatio()
public double getBackgroundRatio()
{
double retVal = getBackgroundRatio_0(nativeObj);
return retVal;
}
//
// C++: double getComplexityReductionThreshold()
//
//javadoc: BackgroundSubtractorMOG2::getComplexityReductionThreshold()
public double getComplexityReductionThreshold()
{
double retVal = getComplexityReductionThreshold_0(nativeObj);
return retVal;
}
//
// C++: double getShadowThreshold()
//
//javadoc: BackgroundSubtractorMOG2::getShadowThreshold()
public double getShadowThreshold()
{
double retVal = getShadowThreshold_0(nativeObj);
return retVal;
}
//
// C++: double getVarInit()
//
//javadoc: BackgroundSubtractorMOG2::getVarInit()
public double getVarInit()
{
double retVal = getVarInit_0(nativeObj);
return retVal;
}
//
// C++: double getVarMax()
//
//javadoc: BackgroundSubtractorMOG2::getVarMax()
public double getVarMax()
{
double retVal = getVarMax_0(nativeObj);
return retVal;
}
//
// C++: double getVarMin()
//
//javadoc: BackgroundSubtractorMOG2::getVarMin()
public double getVarMin()
{
double retVal = getVarMin_0(nativeObj);
return retVal;
}
//
// C++: double getVarThreshold()
//
//javadoc: BackgroundSubtractorMOG2::getVarThreshold()
public double getVarThreshold()
{
double retVal = getVarThreshold_0(nativeObj);
return retVal;
}
//
// C++: double getVarThresholdGen()
//
//javadoc: BackgroundSubtractorMOG2::getVarThresholdGen()
public double getVarThresholdGen()
{
double retVal = getVarThresholdGen_0(nativeObj);
return retVal;
}
//
// C++: int getHistory()
//
//javadoc: BackgroundSubtractorMOG2::getHistory()
public int getHistory()
{
int retVal = getHistory_0(nativeObj);
return retVal;
}
//
// C++: int getNMixtures()
//
//javadoc: BackgroundSubtractorMOG2::getNMixtures()
public int getNMixtures()
{
int retVal = getNMixtures_0(nativeObj);
return retVal;
}
//
// C++: int getShadowValue()
//
//javadoc: BackgroundSubtractorMOG2::getShadowValue()
public int getShadowValue()
{
int retVal = getShadowValue_0(nativeObj);
return retVal;
}
//
// C++: void setBackgroundRatio(double ratio)
//
//javadoc: BackgroundSubtractorMOG2::setBackgroundRatio(ratio)
public void setBackgroundRatio(double ratio)
{
setBackgroundRatio_0(nativeObj, ratio);
return;
}
//
// C++: void setComplexityReductionThreshold(double ct)
//
//javadoc: BackgroundSubtractorMOG2::setComplexityReductionThreshold(ct)
public void setComplexityReductionThreshold(double ct)
{
setComplexityReductionThreshold_0(nativeObj, ct);
return;
}
//
// C++: void setDetectShadows(bool detectShadows)
//
//javadoc: BackgroundSubtractorMOG2::setDetectShadows(detectShadows)
public void setDetectShadows(boolean detectShadows)
{
setDetectShadows_0(nativeObj, detectShadows);
return;
}
//
// C++: void setHistory(int history)
//
//javadoc: BackgroundSubtractorMOG2::setHistory(history)
public void setHistory(int history)
{
setHistory_0(nativeObj, history);
return;
}
//
// C++: void setNMixtures(int nmixtures)
//
//javadoc: BackgroundSubtractorMOG2::setNMixtures(nmixtures)
public void setNMixtures(int nmixtures)
{
setNMixtures_0(nativeObj, nmixtures);
return;
}
//
// C++: void setShadowThreshold(double threshold)
//
//javadoc: BackgroundSubtractorMOG2::setShadowThreshold(threshold)
public void setShadowThreshold(double threshold)
{
setShadowThreshold_0(nativeObj, threshold);
return;
}
//
// C++: void setShadowValue(int value)
//
//javadoc: BackgroundSubtractorMOG2::setShadowValue(value)
public void setShadowValue(int value)
{
setShadowValue_0(nativeObj, value);
return;
}
//
// C++: void setVarInit(double varInit)
//
//javadoc: BackgroundSubtractorMOG2::setVarInit(varInit)
public void setVarInit(double varInit)
{
setVarInit_0(nativeObj, varInit);
return;
}
//
// C++: void setVarMax(double varMax)
//
//javadoc: BackgroundSubtractorMOG2::setVarMax(varMax)
public void setVarMax(double varMax)
{
setVarMax_0(nativeObj, varMax);
return;
}
//
// C++: void setVarMin(double varMin)
//
//javadoc: BackgroundSubtractorMOG2::setVarMin(varMin)
public void setVarMin(double varMin)
{
setVarMin_0(nativeObj, varMin);
return;
}
//
// C++: void setVarThreshold(double varThreshold)
//
//javadoc: BackgroundSubtractorMOG2::setVarThreshold(varThreshold)
public void setVarThreshold(double varThreshold)
{
setVarThreshold_0(nativeObj, varThreshold);
return;
}
//
// C++: void setVarThresholdGen(double varThresholdGen)
//
//javadoc: BackgroundSubtractorMOG2::setVarThresholdGen(varThresholdGen)
public void setVarThresholdGen(double varThresholdGen)
{
setVarThresholdGen_0(nativeObj, varThresholdGen);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: bool getDetectShadows()
private static native boolean getDetectShadows_0(long nativeObj);
// C++: double getBackgroundRatio()
private static native double getBackgroundRatio_0(long nativeObj);
// C++: double getComplexityReductionThreshold()
private static native double getComplexityReductionThreshold_0(long nativeObj);
// C++: double getShadowThreshold()
private static native double getShadowThreshold_0(long nativeObj);
// C++: double getVarInit()
private static native double getVarInit_0(long nativeObj);
// C++: double getVarMax()
private static native double getVarMax_0(long nativeObj);
// C++: double getVarMin()
private static native double getVarMin_0(long nativeObj);
// C++: double getVarThreshold()
private static native double getVarThreshold_0(long nativeObj);
// C++: double getVarThresholdGen()
private static native double getVarThresholdGen_0(long nativeObj);
// C++: int getHistory()
private static native int getHistory_0(long nativeObj);
// C++: int getNMixtures()
private static native int getNMixtures_0(long nativeObj);
// C++: int getShadowValue()
private static native int getShadowValue_0(long nativeObj);
// C++: void setBackgroundRatio(double ratio)
private static native void setBackgroundRatio_0(long nativeObj, double ratio);
// C++: void setComplexityReductionThreshold(double ct)
private static native void setComplexityReductionThreshold_0(long nativeObj, double ct);
// C++: void setDetectShadows(bool detectShadows)
private static native void setDetectShadows_0(long nativeObj, boolean detectShadows);
// C++: void setHistory(int history)
private static native void setHistory_0(long nativeObj, int history);
// C++: void setNMixtures(int nmixtures)
private static native void setNMixtures_0(long nativeObj, int nmixtures);
// C++: void setShadowThreshold(double threshold)
private static native void setShadowThreshold_0(long nativeObj, double threshold);
// C++: void setShadowValue(int value)
private static native void setShadowValue_0(long nativeObj, int value);
// C++: void setVarInit(double varInit)
private static native void setVarInit_0(long nativeObj, double varInit);
// C++: void setVarMax(double varMax)
private static native void setVarMax_0(long nativeObj, double varMax);
// C++: void setVarMin(double varMin)
private static native void setVarMin_0(long nativeObj, double varMin);
// C++: void setVarThreshold(double varThreshold)
private static native void setVarThreshold_0(long nativeObj, double varThreshold);
// C++: void setVarThresholdGen(double varThresholdGen)
private static native void setVarThresholdGen_0(long nativeObj, double varThresholdGen);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 9,769 | 21.45977 | 92 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/video/BackgroundSubtractor.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.video;
import org.opencv.core.Algorithm;
import org.opencv.core.Mat;
// C++: class BackgroundSubtractor
//javadoc: BackgroundSubtractor
public class BackgroundSubtractor extends Algorithm {
protected BackgroundSubtractor(long addr) { super(addr); }
//
// C++: void apply(Mat image, Mat& fgmask, double learningRate = -1)
//
//javadoc: BackgroundSubtractor::apply(image, fgmask, learningRate)
public void apply(Mat image, Mat fgmask, double learningRate)
{
apply_0(nativeObj, image.nativeObj, fgmask.nativeObj, learningRate);
return;
}
//javadoc: BackgroundSubtractor::apply(image, fgmask)
public void apply(Mat image, Mat fgmask)
{
apply_1(nativeObj, image.nativeObj, fgmask.nativeObj);
return;
}
//
// C++: void getBackgroundImage(Mat& backgroundImage)
//
//javadoc: BackgroundSubtractor::getBackgroundImage(backgroundImage)
public void getBackgroundImage(Mat backgroundImage)
{
getBackgroundImage_0(nativeObj, backgroundImage.nativeObj);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: void apply(Mat image, Mat& fgmask, double learningRate = -1)
private static native void apply_0(long nativeObj, long image_nativeObj, long fgmask_nativeObj, double learningRate);
private static native void apply_1(long nativeObj, long image_nativeObj, long fgmask_nativeObj);
// C++: void getBackgroundImage(Mat& backgroundImage)
private static native void getBackgroundImage_0(long nativeObj, long backgroundImage_nativeObj);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 1,885 | 25.194444 | 121 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/features2d/Features2d.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.features2d;
import java.util.ArrayList;
import java.util.List;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.MatOfDMatch;
import org.opencv.core.MatOfKeyPoint;
import org.opencv.core.Scalar;
import org.opencv.utils.Converters;
public class Features2d {
public static final int
DRAW_OVER_OUTIMG = 1,
NOT_DRAW_SINGLE_POINTS = 2,
DRAW_RICH_KEYPOINTS = 4;
//
// C++: void drawKeypoints(Mat image, vector_KeyPoint keypoints, Mat outImage, Scalar color = Scalar::all(-1), int flags = 0)
//
//javadoc: drawKeypoints(image, keypoints, outImage, color, flags)
public static void drawKeypoints(Mat image, MatOfKeyPoint keypoints, Mat outImage, Scalar color, int flags)
{
Mat keypoints_mat = keypoints;
drawKeypoints_0(image.nativeObj, keypoints_mat.nativeObj, outImage.nativeObj, color.val[0], color.val[1], color.val[2], color.val[3], flags);
return;
}
//javadoc: drawKeypoints(image, keypoints, outImage)
public static void drawKeypoints(Mat image, MatOfKeyPoint keypoints, Mat outImage)
{
Mat keypoints_mat = keypoints;
drawKeypoints_1(image.nativeObj, keypoints_mat.nativeObj, outImage.nativeObj);
return;
}
//
// C++: void drawMatches(Mat img1, vector_KeyPoint keypoints1, Mat img2, vector_KeyPoint keypoints2, vector_DMatch matches1to2, Mat outImg, Scalar matchColor = Scalar::all(-1), Scalar singlePointColor = Scalar::all(-1), vector_char matchesMask = std::vector<char>(), int flags = 0)
//
//javadoc: drawMatches(img1, keypoints1, img2, keypoints2, matches1to2, outImg, matchColor, singlePointColor, matchesMask, flags)
public static void drawMatches(Mat img1, MatOfKeyPoint keypoints1, Mat img2, MatOfKeyPoint keypoints2, MatOfDMatch matches1to2, Mat outImg, Scalar matchColor, Scalar singlePointColor, MatOfByte matchesMask, int flags)
{
Mat keypoints1_mat = keypoints1;
Mat keypoints2_mat = keypoints2;
Mat matches1to2_mat = matches1to2;
Mat matchesMask_mat = matchesMask;
drawMatches_0(img1.nativeObj, keypoints1_mat.nativeObj, img2.nativeObj, keypoints2_mat.nativeObj, matches1to2_mat.nativeObj, outImg.nativeObj, matchColor.val[0], matchColor.val[1], matchColor.val[2], matchColor.val[3], singlePointColor.val[0], singlePointColor.val[1], singlePointColor.val[2], singlePointColor.val[3], matchesMask_mat.nativeObj, flags);
return;
}
//javadoc: drawMatches(img1, keypoints1, img2, keypoints2, matches1to2, outImg)
public static void drawMatches(Mat img1, MatOfKeyPoint keypoints1, Mat img2, MatOfKeyPoint keypoints2, MatOfDMatch matches1to2, Mat outImg)
{
Mat keypoints1_mat = keypoints1;
Mat keypoints2_mat = keypoints2;
Mat matches1to2_mat = matches1to2;
drawMatches_1(img1.nativeObj, keypoints1_mat.nativeObj, img2.nativeObj, keypoints2_mat.nativeObj, matches1to2_mat.nativeObj, outImg.nativeObj);
return;
}
//
// C++: void drawMatches(Mat img1, vector_KeyPoint keypoints1, Mat img2, vector_KeyPoint keypoints2, vector_vector_DMatch matches1to2, Mat outImg, Scalar matchColor = Scalar::all(-1), Scalar singlePointColor = Scalar::all(-1), vector_vector_char matchesMask = std::vector<std::vector<char> >(), int flags = 0)
//
//javadoc: drawMatches(img1, keypoints1, img2, keypoints2, matches1to2, outImg, matchColor, singlePointColor, matchesMask, flags)
public static void drawMatches2(Mat img1, MatOfKeyPoint keypoints1, Mat img2, MatOfKeyPoint keypoints2, List<MatOfDMatch> matches1to2, Mat outImg, Scalar matchColor, Scalar singlePointColor, List<MatOfByte> matchesMask, int flags)
{
Mat keypoints1_mat = keypoints1;
Mat keypoints2_mat = keypoints2;
List<Mat> matches1to2_tmplm = new ArrayList<Mat>((matches1to2 != null) ? matches1to2.size() : 0);
Mat matches1to2_mat = Converters.vector_vector_DMatch_to_Mat(matches1to2, matches1to2_tmplm);
List<Mat> matchesMask_tmplm = new ArrayList<Mat>((matchesMask != null) ? matchesMask.size() : 0);
Mat matchesMask_mat = Converters.vector_vector_char_to_Mat(matchesMask, matchesMask_tmplm);
drawMatches2_0(img1.nativeObj, keypoints1_mat.nativeObj, img2.nativeObj, keypoints2_mat.nativeObj, matches1to2_mat.nativeObj, outImg.nativeObj, matchColor.val[0], matchColor.val[1], matchColor.val[2], matchColor.val[3], singlePointColor.val[0], singlePointColor.val[1], singlePointColor.val[2], singlePointColor.val[3], matchesMask_mat.nativeObj, flags);
return;
}
//javadoc: drawMatches(img1, keypoints1, img2, keypoints2, matches1to2, outImg)
public static void drawMatches2(Mat img1, MatOfKeyPoint keypoints1, Mat img2, MatOfKeyPoint keypoints2, List<MatOfDMatch> matches1to2, Mat outImg)
{
Mat keypoints1_mat = keypoints1;
Mat keypoints2_mat = keypoints2;
List<Mat> matches1to2_tmplm = new ArrayList<Mat>((matches1to2 != null) ? matches1to2.size() : 0);
Mat matches1to2_mat = Converters.vector_vector_DMatch_to_Mat(matches1to2, matches1to2_tmplm);
drawMatches2_1(img1.nativeObj, keypoints1_mat.nativeObj, img2.nativeObj, keypoints2_mat.nativeObj, matches1to2_mat.nativeObj, outImg.nativeObj);
return;
}
// C++: void drawKeypoints(Mat image, vector_KeyPoint keypoints, Mat outImage, Scalar color = Scalar::all(-1), int flags = 0)
private static native void drawKeypoints_0(long image_nativeObj, long keypoints_mat_nativeObj, long outImage_nativeObj, double color_val0, double color_val1, double color_val2, double color_val3, int flags);
private static native void drawKeypoints_1(long image_nativeObj, long keypoints_mat_nativeObj, long outImage_nativeObj);
// C++: void drawMatches(Mat img1, vector_KeyPoint keypoints1, Mat img2, vector_KeyPoint keypoints2, vector_DMatch matches1to2, Mat outImg, Scalar matchColor = Scalar::all(-1), Scalar singlePointColor = Scalar::all(-1), vector_char matchesMask = std::vector<char>(), int flags = 0)
private static native void drawMatches_0(long img1_nativeObj, long keypoints1_mat_nativeObj, long img2_nativeObj, long keypoints2_mat_nativeObj, long matches1to2_mat_nativeObj, long outImg_nativeObj, double matchColor_val0, double matchColor_val1, double matchColor_val2, double matchColor_val3, double singlePointColor_val0, double singlePointColor_val1, double singlePointColor_val2, double singlePointColor_val3, long matchesMask_mat_nativeObj, int flags);
private static native void drawMatches_1(long img1_nativeObj, long keypoints1_mat_nativeObj, long img2_nativeObj, long keypoints2_mat_nativeObj, long matches1to2_mat_nativeObj, long outImg_nativeObj);
// C++: void drawMatches(Mat img1, vector_KeyPoint keypoints1, Mat img2, vector_KeyPoint keypoints2, vector_vector_DMatch matches1to2, Mat outImg, Scalar matchColor = Scalar::all(-1), Scalar singlePointColor = Scalar::all(-1), vector_vector_char matchesMask = std::vector<std::vector<char> >(), int flags = 0)
private static native void drawMatches2_0(long img1_nativeObj, long keypoints1_mat_nativeObj, long img2_nativeObj, long keypoints2_mat_nativeObj, long matches1to2_mat_nativeObj, long outImg_nativeObj, double matchColor_val0, double matchColor_val1, double matchColor_val2, double matchColor_val3, double singlePointColor_val0, double singlePointColor_val1, double singlePointColor_val2, double singlePointColor_val3, long matchesMask_mat_nativeObj, int flags);
private static native void drawMatches2_1(long img1_nativeObj, long keypoints1_mat_nativeObj, long img2_nativeObj, long keypoints2_mat_nativeObj, long matches1to2_mat_nativeObj, long outImg_nativeObj);
}
| 7,883 | 64.157025 | 464 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/features2d/FeatureDetector.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.features2d;
import java.lang.String;
import java.util.ArrayList;
import java.util.List;
import org.opencv.core.Mat;
import org.opencv.core.MatOfKeyPoint;
import org.opencv.utils.Converters;
// C++: class javaFeatureDetector
//javadoc: javaFeatureDetector
public class FeatureDetector {
protected final long nativeObj;
protected FeatureDetector(long addr) { nativeObj = addr; }
private static final int
GRIDDETECTOR = 1000,
PYRAMIDDETECTOR = 2000,
DYNAMICDETECTOR = 3000;
public static final int
FAST = 1,
STAR = 2,
SIFT = 3,
SURF = 4,
ORB = 5,
MSER = 6,
GFTT = 7,
HARRIS = 8,
SIMPLEBLOB = 9,
DENSE = 10,
BRISK = 11,
AKAZE = 12,
GRID_FAST = GRIDDETECTOR + FAST,
GRID_STAR = GRIDDETECTOR + STAR,
GRID_SIFT = GRIDDETECTOR + SIFT,
GRID_SURF = GRIDDETECTOR + SURF,
GRID_ORB = GRIDDETECTOR + ORB,
GRID_MSER = GRIDDETECTOR + MSER,
GRID_GFTT = GRIDDETECTOR + GFTT,
GRID_HARRIS = GRIDDETECTOR + HARRIS,
GRID_SIMPLEBLOB = GRIDDETECTOR + SIMPLEBLOB,
GRID_DENSE = GRIDDETECTOR + DENSE,
GRID_BRISK = GRIDDETECTOR + BRISK,
GRID_AKAZE = GRIDDETECTOR + AKAZE,
PYRAMID_FAST = PYRAMIDDETECTOR + FAST,
PYRAMID_STAR = PYRAMIDDETECTOR + STAR,
PYRAMID_SIFT = PYRAMIDDETECTOR + SIFT,
PYRAMID_SURF = PYRAMIDDETECTOR + SURF,
PYRAMID_ORB = PYRAMIDDETECTOR + ORB,
PYRAMID_MSER = PYRAMIDDETECTOR + MSER,
PYRAMID_GFTT = PYRAMIDDETECTOR + GFTT,
PYRAMID_HARRIS = PYRAMIDDETECTOR + HARRIS,
PYRAMID_SIMPLEBLOB = PYRAMIDDETECTOR + SIMPLEBLOB,
PYRAMID_DENSE = PYRAMIDDETECTOR + DENSE,
PYRAMID_BRISK = PYRAMIDDETECTOR + BRISK,
PYRAMID_AKAZE = PYRAMIDDETECTOR + AKAZE,
DYNAMIC_FAST = DYNAMICDETECTOR + FAST,
DYNAMIC_STAR = DYNAMICDETECTOR + STAR,
DYNAMIC_SIFT = DYNAMICDETECTOR + SIFT,
DYNAMIC_SURF = DYNAMICDETECTOR + SURF,
DYNAMIC_ORB = DYNAMICDETECTOR + ORB,
DYNAMIC_MSER = DYNAMICDETECTOR + MSER,
DYNAMIC_GFTT = DYNAMICDETECTOR + GFTT,
DYNAMIC_HARRIS = DYNAMICDETECTOR + HARRIS,
DYNAMIC_SIMPLEBLOB = DYNAMICDETECTOR + SIMPLEBLOB,
DYNAMIC_DENSE = DYNAMICDETECTOR + DENSE,
DYNAMIC_BRISK = DYNAMICDETECTOR + BRISK,
DYNAMIC_AKAZE = DYNAMICDETECTOR + AKAZE;
//
// C++: bool empty()
//
//javadoc: javaFeatureDetector::empty()
public boolean empty()
{
boolean retVal = empty_0(nativeObj);
return retVal;
}
//
// C++: static javaFeatureDetector* create(int detectorType)
//
//javadoc: javaFeatureDetector::create(detectorType)
public static FeatureDetector create(int detectorType)
{
FeatureDetector retVal = new FeatureDetector(create_0(detectorType));
return retVal;
}
//
// C++: void detect(Mat image, vector_KeyPoint& keypoints, Mat mask = Mat())
//
//javadoc: javaFeatureDetector::detect(image, keypoints, mask)
public void detect(Mat image, MatOfKeyPoint keypoints, Mat mask)
{
Mat keypoints_mat = keypoints;
detect_0(nativeObj, image.nativeObj, keypoints_mat.nativeObj, mask.nativeObj);
return;
}
//javadoc: javaFeatureDetector::detect(image, keypoints)
public void detect(Mat image, MatOfKeyPoint keypoints)
{
Mat keypoints_mat = keypoints;
detect_1(nativeObj, image.nativeObj, keypoints_mat.nativeObj);
return;
}
//
// C++: void detect(vector_Mat images, vector_vector_KeyPoint& keypoints, vector_Mat masks = std::vector<Mat>())
//
//javadoc: javaFeatureDetector::detect(images, keypoints, masks)
public void detect(List<Mat> images, List<MatOfKeyPoint> keypoints, List<Mat> masks)
{
Mat images_mat = Converters.vector_Mat_to_Mat(images);
Mat keypoints_mat = new Mat();
Mat masks_mat = Converters.vector_Mat_to_Mat(masks);
detect_2(nativeObj, images_mat.nativeObj, keypoints_mat.nativeObj, masks_mat.nativeObj);
Converters.Mat_to_vector_vector_KeyPoint(keypoints_mat, keypoints);
keypoints_mat.release();
return;
}
//javadoc: javaFeatureDetector::detect(images, keypoints)
public void detect(List<Mat> images, List<MatOfKeyPoint> keypoints)
{
Mat images_mat = Converters.vector_Mat_to_Mat(images);
Mat keypoints_mat = new Mat();
detect_3(nativeObj, images_mat.nativeObj, keypoints_mat.nativeObj);
Converters.Mat_to_vector_vector_KeyPoint(keypoints_mat, keypoints);
keypoints_mat.release();
return;
}
//
// C++: void read(String fileName)
//
//javadoc: javaFeatureDetector::read(fileName)
public void read(String fileName)
{
read_0(nativeObj, fileName);
return;
}
//
// C++: void write(String fileName)
//
//javadoc: javaFeatureDetector::write(fileName)
public void write(String fileName)
{
write_0(nativeObj, fileName);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: bool empty()
private static native boolean empty_0(long nativeObj);
// C++: static javaFeatureDetector* create(int detectorType)
private static native long create_0(int detectorType);
// C++: void detect(Mat image, vector_KeyPoint& keypoints, Mat mask = Mat())
private static native void detect_0(long nativeObj, long image_nativeObj, long keypoints_mat_nativeObj, long mask_nativeObj);
private static native void detect_1(long nativeObj, long image_nativeObj, long keypoints_mat_nativeObj);
// C++: void detect(vector_Mat images, vector_vector_KeyPoint& keypoints, vector_Mat masks = std::vector<Mat>())
private static native void detect_2(long nativeObj, long images_mat_nativeObj, long keypoints_mat_nativeObj, long masks_mat_nativeObj);
private static native void detect_3(long nativeObj, long images_mat_nativeObj, long keypoints_mat_nativeObj);
// C++: void read(String fileName)
private static native void read_0(long nativeObj, String fileName);
// C++: void write(String fileName)
private static native void write_0(long nativeObj, String fileName);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 6,888 | 30.746544 | 139 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/features2d/DescriptorExtractor.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.features2d;
import java.lang.String;
import java.util.ArrayList;
import java.util.List;
import org.opencv.core.Mat;
import org.opencv.core.MatOfKeyPoint;
import org.opencv.utils.Converters;
// C++: class javaDescriptorExtractor
//javadoc: javaDescriptorExtractor
public class DescriptorExtractor {
protected final long nativeObj;
protected DescriptorExtractor(long addr) { nativeObj = addr; }
private static final int
OPPONENTEXTRACTOR = 1000;
public static final int
SIFT = 1,
SURF = 2,
ORB = 3,
BRIEF = 4,
BRISK = 5,
FREAK = 6,
AKAZE = 7,
OPPONENT_SIFT = OPPONENTEXTRACTOR + SIFT,
OPPONENT_SURF = OPPONENTEXTRACTOR + SURF,
OPPONENT_ORB = OPPONENTEXTRACTOR + ORB,
OPPONENT_BRIEF = OPPONENTEXTRACTOR + BRIEF,
OPPONENT_BRISK = OPPONENTEXTRACTOR + BRISK,
OPPONENT_FREAK = OPPONENTEXTRACTOR + FREAK,
OPPONENT_AKAZE = OPPONENTEXTRACTOR + AKAZE;
//
// C++: bool empty()
//
//javadoc: javaDescriptorExtractor::empty()
public boolean empty()
{
boolean retVal = empty_0(nativeObj);
return retVal;
}
//
// C++: int descriptorSize()
//
//javadoc: javaDescriptorExtractor::descriptorSize()
public int descriptorSize()
{
int retVal = descriptorSize_0(nativeObj);
return retVal;
}
//
// C++: int descriptorType()
//
//javadoc: javaDescriptorExtractor::descriptorType()
public int descriptorType()
{
int retVal = descriptorType_0(nativeObj);
return retVal;
}
//
// C++: static javaDescriptorExtractor* create(int extractorType)
//
//javadoc: javaDescriptorExtractor::create(extractorType)
public static DescriptorExtractor create(int extractorType)
{
DescriptorExtractor retVal = new DescriptorExtractor(create_0(extractorType));
return retVal;
}
//
// C++: void compute(Mat image, vector_KeyPoint& keypoints, Mat descriptors)
//
//javadoc: javaDescriptorExtractor::compute(image, keypoints, descriptors)
public void compute(Mat image, MatOfKeyPoint keypoints, Mat descriptors)
{
Mat keypoints_mat = keypoints;
compute_0(nativeObj, image.nativeObj, keypoints_mat.nativeObj, descriptors.nativeObj);
return;
}
//
// C++: void compute(vector_Mat images, vector_vector_KeyPoint& keypoints, vector_Mat& descriptors)
//
//javadoc: javaDescriptorExtractor::compute(images, keypoints, descriptors)
public void compute(List<Mat> images, List<MatOfKeyPoint> keypoints, List<Mat> descriptors)
{
Mat images_mat = Converters.vector_Mat_to_Mat(images);
List<Mat> keypoints_tmplm = new ArrayList<Mat>((keypoints != null) ? keypoints.size() : 0);
Mat keypoints_mat = Converters.vector_vector_KeyPoint_to_Mat(keypoints, keypoints_tmplm);
Mat descriptors_mat = new Mat();
compute_1(nativeObj, images_mat.nativeObj, keypoints_mat.nativeObj, descriptors_mat.nativeObj);
Converters.Mat_to_vector_vector_KeyPoint(keypoints_mat, keypoints);
keypoints_mat.release();
Converters.Mat_to_vector_Mat(descriptors_mat, descriptors);
descriptors_mat.release();
return;
}
//
// C++: void read(String fileName)
//
//javadoc: javaDescriptorExtractor::read(fileName)
public void read(String fileName)
{
read_0(nativeObj, fileName);
return;
}
//
// C++: void write(String fileName)
//
//javadoc: javaDescriptorExtractor::write(fileName)
public void write(String fileName)
{
write_0(nativeObj, fileName);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: bool empty()
private static native boolean empty_0(long nativeObj);
// C++: int descriptorSize()
private static native int descriptorSize_0(long nativeObj);
// C++: int descriptorType()
private static native int descriptorType_0(long nativeObj);
// C++: static javaDescriptorExtractor* create(int extractorType)
private static native long create_0(int extractorType);
// C++: void compute(Mat image, vector_KeyPoint& keypoints, Mat descriptors)
private static native void compute_0(long nativeObj, long image_nativeObj, long keypoints_mat_nativeObj, long descriptors_nativeObj);
// C++: void compute(vector_Mat images, vector_vector_KeyPoint& keypoints, vector_Mat& descriptors)
private static native void compute_1(long nativeObj, long images_mat_nativeObj, long keypoints_mat_nativeObj, long descriptors_mat_nativeObj);
// C++: void read(String fileName)
private static native void read_0(long nativeObj, String fileName);
// C++: void write(String fileName)
private static native void write_0(long nativeObj, String fileName);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 5,346 | 26.280612 | 146 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/features2d/DescriptorMatcher.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.features2d;
import java.lang.String;
import java.util.ArrayList;
import java.util.List;
import org.opencv.core.Mat;
import org.opencv.core.MatOfDMatch;
import org.opencv.utils.Converters;
// C++: class javaDescriptorMatcher
//javadoc: javaDescriptorMatcher
public class DescriptorMatcher {
protected final long nativeObj;
protected DescriptorMatcher(long addr) { nativeObj = addr; }
public static final int
FLANNBASED = 1,
BRUTEFORCE = 2,
BRUTEFORCE_L1 = 3,
BRUTEFORCE_HAMMING = 4,
BRUTEFORCE_HAMMINGLUT = 5,
BRUTEFORCE_SL2 = 6;
//
// C++: bool empty()
//
//javadoc: javaDescriptorMatcher::empty()
public boolean empty()
{
boolean retVal = empty_0(nativeObj);
return retVal;
}
//
// C++: bool isMaskSupported()
//
//javadoc: javaDescriptorMatcher::isMaskSupported()
public boolean isMaskSupported()
{
boolean retVal = isMaskSupported_0(nativeObj);
return retVal;
}
//
// C++: static javaDescriptorMatcher* create(int matcherType)
//
//javadoc: javaDescriptorMatcher::create(matcherType)
public static DescriptorMatcher create(int matcherType)
{
DescriptorMatcher retVal = new DescriptorMatcher(create_0(matcherType));
return retVal;
}
//
// C++: javaDescriptorMatcher* jclone(bool emptyTrainData = false)
//
//javadoc: javaDescriptorMatcher::jclone(emptyTrainData)
public DescriptorMatcher clone(boolean emptyTrainData)
{
DescriptorMatcher retVal = new DescriptorMatcher(clone_0(nativeObj, emptyTrainData));
return retVal;
}
//javadoc: javaDescriptorMatcher::jclone()
public DescriptorMatcher clone()
{
DescriptorMatcher retVal = new DescriptorMatcher(clone_1(nativeObj));
return retVal;
}
//
// C++: vector_Mat getTrainDescriptors()
//
//javadoc: javaDescriptorMatcher::getTrainDescriptors()
public List<Mat> getTrainDescriptors()
{
List<Mat> retVal = new ArrayList<Mat>();
Mat retValMat = new Mat(getTrainDescriptors_0(nativeObj));
Converters.Mat_to_vector_Mat(retValMat, retVal);
return retVal;
}
//
// C++: void add(vector_Mat descriptors)
//
//javadoc: javaDescriptorMatcher::add(descriptors)
public void add(List<Mat> descriptors)
{
Mat descriptors_mat = Converters.vector_Mat_to_Mat(descriptors);
add_0(nativeObj, descriptors_mat.nativeObj);
return;
}
//
// C++: void clear()
//
//javadoc: javaDescriptorMatcher::clear()
public void clear()
{
clear_0(nativeObj);
return;
}
//
// C++: void knnMatch(Mat queryDescriptors, Mat trainDescriptors, vector_vector_DMatch& matches, int k, Mat mask = Mat(), bool compactResult = false)
//
//javadoc: javaDescriptorMatcher::knnMatch(queryDescriptors, trainDescriptors, matches, k, mask, compactResult)
public void knnMatch(Mat queryDescriptors, Mat trainDescriptors, List<MatOfDMatch> matches, int k, Mat mask, boolean compactResult)
{
Mat matches_mat = new Mat();
knnMatch_0(nativeObj, queryDescriptors.nativeObj, trainDescriptors.nativeObj, matches_mat.nativeObj, k, mask.nativeObj, compactResult);
Converters.Mat_to_vector_vector_DMatch(matches_mat, matches);
matches_mat.release();
return;
}
//javadoc: javaDescriptorMatcher::knnMatch(queryDescriptors, trainDescriptors, matches, k)
public void knnMatch(Mat queryDescriptors, Mat trainDescriptors, List<MatOfDMatch> matches, int k)
{
Mat matches_mat = new Mat();
knnMatch_1(nativeObj, queryDescriptors.nativeObj, trainDescriptors.nativeObj, matches_mat.nativeObj, k);
Converters.Mat_to_vector_vector_DMatch(matches_mat, matches);
matches_mat.release();
return;
}
//
// C++: void knnMatch(Mat queryDescriptors, vector_vector_DMatch& matches, int k, vector_Mat masks = std::vector<Mat>(), bool compactResult = false)
//
//javadoc: javaDescriptorMatcher::knnMatch(queryDescriptors, matches, k, masks, compactResult)
public void knnMatch(Mat queryDescriptors, List<MatOfDMatch> matches, int k, List<Mat> masks, boolean compactResult)
{
Mat matches_mat = new Mat();
Mat masks_mat = Converters.vector_Mat_to_Mat(masks);
knnMatch_2(nativeObj, queryDescriptors.nativeObj, matches_mat.nativeObj, k, masks_mat.nativeObj, compactResult);
Converters.Mat_to_vector_vector_DMatch(matches_mat, matches);
matches_mat.release();
return;
}
//javadoc: javaDescriptorMatcher::knnMatch(queryDescriptors, matches, k)
public void knnMatch(Mat queryDescriptors, List<MatOfDMatch> matches, int k)
{
Mat matches_mat = new Mat();
knnMatch_3(nativeObj, queryDescriptors.nativeObj, matches_mat.nativeObj, k);
Converters.Mat_to_vector_vector_DMatch(matches_mat, matches);
matches_mat.release();
return;
}
//
// C++: void match(Mat queryDescriptors, Mat trainDescriptors, vector_DMatch& matches, Mat mask = Mat())
//
//javadoc: javaDescriptorMatcher::match(queryDescriptors, trainDescriptors, matches, mask)
public void match(Mat queryDescriptors, Mat trainDescriptors, MatOfDMatch matches, Mat mask)
{
Mat matches_mat = matches;
match_0(nativeObj, queryDescriptors.nativeObj, trainDescriptors.nativeObj, matches_mat.nativeObj, mask.nativeObj);
return;
}
//javadoc: javaDescriptorMatcher::match(queryDescriptors, trainDescriptors, matches)
public void match(Mat queryDescriptors, Mat trainDescriptors, MatOfDMatch matches)
{
Mat matches_mat = matches;
match_1(nativeObj, queryDescriptors.nativeObj, trainDescriptors.nativeObj, matches_mat.nativeObj);
return;
}
//
// C++: void match(Mat queryDescriptors, vector_DMatch& matches, vector_Mat masks = std::vector<Mat>())
//
//javadoc: javaDescriptorMatcher::match(queryDescriptors, matches, masks)
public void match(Mat queryDescriptors, MatOfDMatch matches, List<Mat> masks)
{
Mat matches_mat = matches;
Mat masks_mat = Converters.vector_Mat_to_Mat(masks);
match_2(nativeObj, queryDescriptors.nativeObj, matches_mat.nativeObj, masks_mat.nativeObj);
return;
}
//javadoc: javaDescriptorMatcher::match(queryDescriptors, matches)
public void match(Mat queryDescriptors, MatOfDMatch matches)
{
Mat matches_mat = matches;
match_3(nativeObj, queryDescriptors.nativeObj, matches_mat.nativeObj);
return;
}
//
// C++: void radiusMatch(Mat queryDescriptors, Mat trainDescriptors, vector_vector_DMatch& matches, float maxDistance, Mat mask = Mat(), bool compactResult = false)
//
//javadoc: javaDescriptorMatcher::radiusMatch(queryDescriptors, trainDescriptors, matches, maxDistance, mask, compactResult)
public void radiusMatch(Mat queryDescriptors, Mat trainDescriptors, List<MatOfDMatch> matches, float maxDistance, Mat mask, boolean compactResult)
{
Mat matches_mat = new Mat();
radiusMatch_0(nativeObj, queryDescriptors.nativeObj, trainDescriptors.nativeObj, matches_mat.nativeObj, maxDistance, mask.nativeObj, compactResult);
Converters.Mat_to_vector_vector_DMatch(matches_mat, matches);
matches_mat.release();
return;
}
//javadoc: javaDescriptorMatcher::radiusMatch(queryDescriptors, trainDescriptors, matches, maxDistance)
public void radiusMatch(Mat queryDescriptors, Mat trainDescriptors, List<MatOfDMatch> matches, float maxDistance)
{
Mat matches_mat = new Mat();
radiusMatch_1(nativeObj, queryDescriptors.nativeObj, trainDescriptors.nativeObj, matches_mat.nativeObj, maxDistance);
Converters.Mat_to_vector_vector_DMatch(matches_mat, matches);
matches_mat.release();
return;
}
//
// C++: void radiusMatch(Mat queryDescriptors, vector_vector_DMatch& matches, float maxDistance, vector_Mat masks = std::vector<Mat>(), bool compactResult = false)
//
//javadoc: javaDescriptorMatcher::radiusMatch(queryDescriptors, matches, maxDistance, masks, compactResult)
public void radiusMatch(Mat queryDescriptors, List<MatOfDMatch> matches, float maxDistance, List<Mat> masks, boolean compactResult)
{
Mat matches_mat = new Mat();
Mat masks_mat = Converters.vector_Mat_to_Mat(masks);
radiusMatch_2(nativeObj, queryDescriptors.nativeObj, matches_mat.nativeObj, maxDistance, masks_mat.nativeObj, compactResult);
Converters.Mat_to_vector_vector_DMatch(matches_mat, matches);
matches_mat.release();
return;
}
//javadoc: javaDescriptorMatcher::radiusMatch(queryDescriptors, matches, maxDistance)
public void radiusMatch(Mat queryDescriptors, List<MatOfDMatch> matches, float maxDistance)
{
Mat matches_mat = new Mat();
radiusMatch_3(nativeObj, queryDescriptors.nativeObj, matches_mat.nativeObj, maxDistance);
Converters.Mat_to_vector_vector_DMatch(matches_mat, matches);
matches_mat.release();
return;
}
//
// C++: void read(String fileName)
//
//javadoc: javaDescriptorMatcher::read(fileName)
public void read(String fileName)
{
read_0(nativeObj, fileName);
return;
}
//
// C++: void train()
//
//javadoc: javaDescriptorMatcher::train()
public void train()
{
train_0(nativeObj);
return;
}
//
// C++: void write(String fileName)
//
//javadoc: javaDescriptorMatcher::write(fileName)
public void write(String fileName)
{
write_0(nativeObj, fileName);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: bool empty()
private static native boolean empty_0(long nativeObj);
// C++: bool isMaskSupported()
private static native boolean isMaskSupported_0(long nativeObj);
// C++: static javaDescriptorMatcher* create(int matcherType)
private static native long create_0(int matcherType);
// C++: javaDescriptorMatcher* jclone(bool emptyTrainData = false)
private static native long clone_0(long nativeObj, boolean emptyTrainData);
private static native long clone_1(long nativeObj);
// C++: vector_Mat getTrainDescriptors()
private static native long getTrainDescriptors_0(long nativeObj);
// C++: void add(vector_Mat descriptors)
private static native void add_0(long nativeObj, long descriptors_mat_nativeObj);
// C++: void clear()
private static native void clear_0(long nativeObj);
// C++: void knnMatch(Mat queryDescriptors, Mat trainDescriptors, vector_vector_DMatch& matches, int k, Mat mask = Mat(), bool compactResult = false)
private static native void knnMatch_0(long nativeObj, long queryDescriptors_nativeObj, long trainDescriptors_nativeObj, long matches_mat_nativeObj, int k, long mask_nativeObj, boolean compactResult);
private static native void knnMatch_1(long nativeObj, long queryDescriptors_nativeObj, long trainDescriptors_nativeObj, long matches_mat_nativeObj, int k);
// C++: void knnMatch(Mat queryDescriptors, vector_vector_DMatch& matches, int k, vector_Mat masks = std::vector<Mat>(), bool compactResult = false)
private static native void knnMatch_2(long nativeObj, long queryDescriptors_nativeObj, long matches_mat_nativeObj, int k, long masks_mat_nativeObj, boolean compactResult);
private static native void knnMatch_3(long nativeObj, long queryDescriptors_nativeObj, long matches_mat_nativeObj, int k);
// C++: void match(Mat queryDescriptors, Mat trainDescriptors, vector_DMatch& matches, Mat mask = Mat())
private static native void match_0(long nativeObj, long queryDescriptors_nativeObj, long trainDescriptors_nativeObj, long matches_mat_nativeObj, long mask_nativeObj);
private static native void match_1(long nativeObj, long queryDescriptors_nativeObj, long trainDescriptors_nativeObj, long matches_mat_nativeObj);
// C++: void match(Mat queryDescriptors, vector_DMatch& matches, vector_Mat masks = std::vector<Mat>())
private static native void match_2(long nativeObj, long queryDescriptors_nativeObj, long matches_mat_nativeObj, long masks_mat_nativeObj);
private static native void match_3(long nativeObj, long queryDescriptors_nativeObj, long matches_mat_nativeObj);
// C++: void radiusMatch(Mat queryDescriptors, Mat trainDescriptors, vector_vector_DMatch& matches, float maxDistance, Mat mask = Mat(), bool compactResult = false)
private static native void radiusMatch_0(long nativeObj, long queryDescriptors_nativeObj, long trainDescriptors_nativeObj, long matches_mat_nativeObj, float maxDistance, long mask_nativeObj, boolean compactResult);
private static native void radiusMatch_1(long nativeObj, long queryDescriptors_nativeObj, long trainDescriptors_nativeObj, long matches_mat_nativeObj, float maxDistance);
// C++: void radiusMatch(Mat queryDescriptors, vector_vector_DMatch& matches, float maxDistance, vector_Mat masks = std::vector<Mat>(), bool compactResult = false)
private static native void radiusMatch_2(long nativeObj, long queryDescriptors_nativeObj, long matches_mat_nativeObj, float maxDistance, long masks_mat_nativeObj, boolean compactResult);
private static native void radiusMatch_3(long nativeObj, long queryDescriptors_nativeObj, long matches_mat_nativeObj, float maxDistance);
// C++: void read(String fileName)
private static native void read_0(long nativeObj, String fileName);
// C++: void train()
private static native void train_0(long nativeObj);
// C++: void write(String fileName)
private static native void write_0(long nativeObj, String fileName);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 14,447 | 35.577215 | 218 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/Algorithm.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.core;
import java.lang.String;
// C++: class Algorithm
//javadoc: Algorithm
public class Algorithm {
protected final long nativeObj;
protected Algorithm(long addr) { nativeObj = addr; }
//
// C++: String getDefaultName()
//
//javadoc: Algorithm::getDefaultName()
public String getDefaultName()
{
String retVal = getDefaultName_0(nativeObj);
return retVal;
}
//
// C++: void clear()
//
//javadoc: Algorithm::clear()
public void clear()
{
clear_0(nativeObj);
return;
}
//
// C++: void save(String filename)
//
//javadoc: Algorithm::save(filename)
public void save(String filename)
{
save_0(nativeObj, filename);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: String getDefaultName()
private static native String getDefaultName_0(long nativeObj);
// C++: void clear()
private static native void clear_0(long nativeObj);
// C++: void save(String filename)
private static native void save_0(long nativeObj, String filename);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 1,416 | 16.936709 | 71 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/MatOfFloat4.java | package org.opencv.core;
import java.util.Arrays;
import java.util.List;
public class MatOfFloat4 extends Mat {
// 32FC4
private static final int _depth = CvType.CV_32F;
private static final int _channels = 4;
public MatOfFloat4() {
super();
}
protected MatOfFloat4(long addr) {
super(addr);
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public static MatOfFloat4 fromNativeAddr(long addr) {
return new MatOfFloat4(addr);
}
public MatOfFloat4(Mat m) {
super(m, Range.all());
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public MatOfFloat4(float...a) {
super();
fromArray(a);
}
public void alloc(int elemNumber) {
if(elemNumber>0)
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
}
public void fromArray(float...a) {
if(a==null || a.length==0)
return;
int num = a.length / _channels;
alloc(num);
put(0, 0, a); //TODO: check ret val!
}
public float[] toArray() {
int num = checkVector(_channels, _depth);
if(num < 0)
throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
float[] a = new float[num * _channels];
if(num == 0)
return a;
get(0, 0, a); //TODO: check ret val!
return a;
}
public void fromList(List<Float> lb) {
if(lb==null || lb.size()==0)
return;
Float ab[] = lb.toArray(new Float[0]);
float a[] = new float[ab.length];
for(int i=0; i<ab.length; i++)
a[i] = ab[i];
fromArray(a);
}
public List<Float> toList() {
float[] a = toArray();
Float ab[] = new Float[a.length];
for(int i=0; i<a.length; i++)
ab[i] = a[i];
return Arrays.asList(ab);
}
}
| 2,154 | 25.9375 | 96 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/DMatch.java | package org.opencv.core;
//C++: class DMatch
/**
* Structure for matching: query descriptor index, train descriptor index, train
* image index and distance between descriptors.
*/
public class DMatch {
/**
* Query descriptor index.
*/
public int queryIdx;
/**
* Train descriptor index.
*/
public int trainIdx;
/**
* Train image index.
*/
public int imgIdx;
// javadoc: DMatch::distance
public float distance;
// javadoc: DMatch::DMatch()
public DMatch() {
this(-1, -1, Float.MAX_VALUE);
}
// javadoc: DMatch::DMatch(_queryIdx, _trainIdx, _distance)
public DMatch(int _queryIdx, int _trainIdx, float _distance) {
queryIdx = _queryIdx;
trainIdx = _trainIdx;
imgIdx = -1;
distance = _distance;
}
// javadoc: DMatch::DMatch(_queryIdx, _trainIdx, _imgIdx, _distance)
public DMatch(int _queryIdx, int _trainIdx, int _imgIdx, float _distance) {
queryIdx = _queryIdx;
trainIdx = _trainIdx;
imgIdx = _imgIdx;
distance = _distance;
}
/**
* Less is better.
*/
public boolean lessThan(DMatch it) {
return distance < it.distance;
}
@Override
public String toString() {
return "DMatch [queryIdx=" + queryIdx + ", trainIdx=" + trainIdx
+ ", imgIdx=" + imgIdx + ", distance=" + distance + "]";
}
}
| 1,431 | 22.096774 | 80 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/MatOfRect.java | package org.opencv.core;
import java.util.Arrays;
import java.util.List;
public class MatOfRect extends Mat {
// 32SC4
private static final int _depth = CvType.CV_32S;
private static final int _channels = 4;
public MatOfRect() {
super();
}
protected MatOfRect(long addr) {
super(addr);
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public static MatOfRect fromNativeAddr(long addr) {
return new MatOfRect(addr);
}
public MatOfRect(Mat m) {
super(m, Range.all());
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public MatOfRect(Rect...a) {
super();
fromArray(a);
}
public void alloc(int elemNumber) {
if(elemNumber>0)
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
}
public void fromArray(Rect...a) {
if(a==null || a.length==0)
return;
int num = a.length;
alloc(num);
int buff[] = new int[num * _channels];
for(int i=0; i<num; i++) {
Rect r = a[i];
buff[_channels*i+0] = (int) r.x;
buff[_channels*i+1] = (int) r.y;
buff[_channels*i+2] = (int) r.width;
buff[_channels*i+3] = (int) r.height;
}
put(0, 0, buff); //TODO: check ret val!
}
public Rect[] toArray() {
int num = (int) total();
Rect[] a = new Rect[num];
if(num == 0)
return a;
int buff[] = new int[num * _channels];
get(0, 0, buff); //TODO: check ret val!
for(int i=0; i<num; i++)
a[i] = new Rect(buff[i*_channels], buff[i*_channels+1], buff[i*_channels+2], buff[i*_channels+3]);
return a;
}
public void fromList(List<Rect> lr) {
Rect ap[] = lr.toArray(new Rect[0]);
fromArray(ap);
}
public List<Rect> toList() {
Rect[] ar = toArray();
return Arrays.asList(ar);
}
}
| 2,210 | 25.963415 | 110 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/MatOfInt.java | package org.opencv.core;
import java.util.Arrays;
import java.util.List;
public class MatOfInt extends Mat {
// 32SC1
private static final int _depth = CvType.CV_32S;
private static final int _channels = 1;
public MatOfInt() {
super();
}
protected MatOfInt(long addr) {
super(addr);
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public static MatOfInt fromNativeAddr(long addr) {
return new MatOfInt(addr);
}
public MatOfInt(Mat m) {
super(m, Range.all());
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public MatOfInt(int...a) {
super();
fromArray(a);
}
public void alloc(int elemNumber) {
if(elemNumber>0)
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
}
public void fromArray(int...a) {
if(a==null || a.length==0)
return;
int num = a.length / _channels;
alloc(num);
put(0, 0, a); //TODO: check ret val!
}
public int[] toArray() {
int num = checkVector(_channels, _depth);
if(num < 0)
throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
int[] a = new int[num * _channels];
if(num == 0)
return a;
get(0, 0, a); //TODO: check ret val!
return a;
}
public void fromList(List<Integer> lb) {
if(lb==null || lb.size()==0)
return;
Integer ab[] = lb.toArray(new Integer[0]);
int a[] = new int[ab.length];
for(int i=0; i<ab.length; i++)
a[i] = ab[i];
fromArray(a);
}
public List<Integer> toList() {
int[] a = toArray();
Integer ab[] = new Integer[a.length];
for(int i=0; i<a.length; i++)
ab[i] = a[i];
return Arrays.asList(ab);
}
}
| 2,130 | 25.308642 | 96 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/Mat.java | package org.opencv.core;
// C++: class Mat
//javadoc: Mat
public class Mat {
public final long nativeObj;
public Mat(long addr)
{
if (addr == 0)
throw new java.lang.UnsupportedOperationException("Native object address is NULL");
nativeObj = addr;
}
//
// C++: Mat::Mat()
//
// javadoc: Mat::Mat()
public Mat()
{
nativeObj = n_Mat();
return;
}
//
// C++: Mat::Mat(int rows, int cols, int type)
//
// javadoc: Mat::Mat(rows, cols, type)
public Mat(int rows, int cols, int type)
{
nativeObj = n_Mat(rows, cols, type);
return;
}
//
// C++: Mat::Mat(Size size, int type)
//
// javadoc: Mat::Mat(size, type)
public Mat(Size size, int type)
{
nativeObj = n_Mat(size.width, size.height, type);
return;
}
//
// C++: Mat::Mat(int rows, int cols, int type, Scalar s)
//
// javadoc: Mat::Mat(rows, cols, type, s)
public Mat(int rows, int cols, int type, Scalar s)
{
nativeObj = n_Mat(rows, cols, type, s.val[0], s.val[1], s.val[2], s.val[3]);
return;
}
//
// C++: Mat::Mat(Size size, int type, Scalar s)
//
// javadoc: Mat::Mat(size, type, s)
public Mat(Size size, int type, Scalar s)
{
nativeObj = n_Mat(size.width, size.height, type, s.val[0], s.val[1], s.val[2], s.val[3]);
return;
}
//
// C++: Mat::Mat(Mat m, Range rowRange, Range colRange = Range::all())
//
// javadoc: Mat::Mat(m, rowRange, colRange)
public Mat(Mat m, Range rowRange, Range colRange)
{
nativeObj = n_Mat(m.nativeObj, rowRange.start, rowRange.end, colRange.start, colRange.end);
return;
}
// javadoc: Mat::Mat(m, rowRange)
public Mat(Mat m, Range rowRange)
{
nativeObj = n_Mat(m.nativeObj, rowRange.start, rowRange.end);
return;
}
//
// C++: Mat::Mat(Mat m, Rect roi)
//
// javadoc: Mat::Mat(m, roi)
public Mat(Mat m, Rect roi)
{
nativeObj = n_Mat(m.nativeObj, roi.y, roi.y + roi.height, roi.x, roi.x + roi.width);
return;
}
//
// C++: Mat Mat::adjustROI(int dtop, int dbottom, int dleft, int dright)
//
// javadoc: Mat::adjustROI(dtop, dbottom, dleft, dright)
public Mat adjustROI(int dtop, int dbottom, int dleft, int dright)
{
Mat retVal = new Mat(n_adjustROI(nativeObj, dtop, dbottom, dleft, dright));
return retVal;
}
//
// C++: void Mat::assignTo(Mat m, int type = -1)
//
// javadoc: Mat::assignTo(m, type)
public void assignTo(Mat m, int type)
{
n_assignTo(nativeObj, m.nativeObj, type);
return;
}
// javadoc: Mat::assignTo(m)
public void assignTo(Mat m)
{
n_assignTo(nativeObj, m.nativeObj);
return;
}
//
// C++: int Mat::channels()
//
// javadoc: Mat::channels()
public int channels()
{
int retVal = n_channels(nativeObj);
return retVal;
}
//
// C++: int Mat::checkVector(int elemChannels, int depth = -1, bool
// requireContinuous = true)
//
// javadoc: Mat::checkVector(elemChannels, depth, requireContinuous)
public int checkVector(int elemChannels, int depth, boolean requireContinuous)
{
int retVal = n_checkVector(nativeObj, elemChannels, depth, requireContinuous);
return retVal;
}
// javadoc: Mat::checkVector(elemChannels, depth)
public int checkVector(int elemChannels, int depth)
{
int retVal = n_checkVector(nativeObj, elemChannels, depth);
return retVal;
}
// javadoc: Mat::checkVector(elemChannels)
public int checkVector(int elemChannels)
{
int retVal = n_checkVector(nativeObj, elemChannels);
return retVal;
}
//
// C++: Mat Mat::clone()
//
// javadoc: Mat::clone()
public Mat clone()
{
Mat retVal = new Mat(n_clone(nativeObj));
return retVal;
}
//
// C++: Mat Mat::col(int x)
//
// javadoc: Mat::col(x)
public Mat col(int x)
{
Mat retVal = new Mat(n_col(nativeObj, x));
return retVal;
}
//
// C++: Mat Mat::colRange(int startcol, int endcol)
//
// javadoc: Mat::colRange(startcol, endcol)
public Mat colRange(int startcol, int endcol)
{
Mat retVal = new Mat(n_colRange(nativeObj, startcol, endcol));
return retVal;
}
//
// C++: Mat Mat::colRange(Range r)
//
// javadoc: Mat::colRange(r)
public Mat colRange(Range r)
{
Mat retVal = new Mat(n_colRange(nativeObj, r.start, r.end));
return retVal;
}
//
// C++: int Mat::dims()
//
// javadoc: Mat::dims()
public int dims()
{
int retVal = n_dims(nativeObj);
return retVal;
}
//
// C++: int Mat::cols()
//
// javadoc: Mat::cols()
public int cols()
{
int retVal = n_cols(nativeObj);
return retVal;
}
//
// C++: void Mat::convertTo(Mat& m, int rtype, double alpha = 1, double beta
// = 0)
//
// javadoc: Mat::convertTo(m, rtype, alpha, beta)
public void convertTo(Mat m, int rtype, double alpha, double beta)
{
n_convertTo(nativeObj, m.nativeObj, rtype, alpha, beta);
return;
}
// javadoc: Mat::convertTo(m, rtype, alpha)
public void convertTo(Mat m, int rtype, double alpha)
{
n_convertTo(nativeObj, m.nativeObj, rtype, alpha);
return;
}
// javadoc: Mat::convertTo(m, rtype)
public void convertTo(Mat m, int rtype)
{
n_convertTo(nativeObj, m.nativeObj, rtype);
return;
}
//
// C++: void Mat::copyTo(Mat& m)
//
// javadoc: Mat::copyTo(m)
public void copyTo(Mat m)
{
n_copyTo(nativeObj, m.nativeObj);
return;
}
//
// C++: void Mat::copyTo(Mat& m, Mat mask)
//
// javadoc: Mat::copyTo(m, mask)
public void copyTo(Mat m, Mat mask)
{
n_copyTo(nativeObj, m.nativeObj, mask.nativeObj);
return;
}
//
// C++: void Mat::create(int rows, int cols, int type)
//
// javadoc: Mat::create(rows, cols, type)
public void create(int rows, int cols, int type)
{
n_create(nativeObj, rows, cols, type);
return;
}
//
// C++: void Mat::create(Size size, int type)
//
// javadoc: Mat::create(size, type)
public void create(Size size, int type)
{
n_create(nativeObj, size.width, size.height, type);
return;
}
//
// C++: Mat Mat::cross(Mat m)
//
// javadoc: Mat::cross(m)
public Mat cross(Mat m)
{
Mat retVal = new Mat(n_cross(nativeObj, m.nativeObj));
return retVal;
}
//
// C++: long Mat::dataAddr()
//
// javadoc: Mat::dataAddr()
public long dataAddr()
{
long retVal = n_dataAddr(nativeObj);
return retVal;
}
//
// C++: int Mat::depth()
//
// javadoc: Mat::depth()
public int depth()
{
int retVal = n_depth(nativeObj);
return retVal;
}
//
// C++: Mat Mat::diag(int d = 0)
//
// javadoc: Mat::diag(d)
public Mat diag(int d)
{
Mat retVal = new Mat(n_diag(nativeObj, d));
return retVal;
}
// javadoc: Mat::diag()
public Mat diag()
{
Mat retVal = new Mat(n_diag(nativeObj, 0));
return retVal;
}
//
// C++: static Mat Mat::diag(Mat d)
//
// javadoc: Mat::diag(d)
public static Mat diag(Mat d)
{
Mat retVal = new Mat(n_diag(d.nativeObj));
return retVal;
}
//
// C++: double Mat::dot(Mat m)
//
// javadoc: Mat::dot(m)
public double dot(Mat m)
{
double retVal = n_dot(nativeObj, m.nativeObj);
return retVal;
}
//
// C++: size_t Mat::elemSize()
//
// javadoc: Mat::elemSize()
public long elemSize()
{
long retVal = n_elemSize(nativeObj);
return retVal;
}
//
// C++: size_t Mat::elemSize1()
//
// javadoc: Mat::elemSize1()
public long elemSize1()
{
long retVal = n_elemSize1(nativeObj);
return retVal;
}
//
// C++: bool Mat::empty()
//
// javadoc: Mat::empty()
public boolean empty()
{
boolean retVal = n_empty(nativeObj);
return retVal;
}
//
// C++: static Mat Mat::eye(int rows, int cols, int type)
//
// javadoc: Mat::eye(rows, cols, type)
public static Mat eye(int rows, int cols, int type)
{
Mat retVal = new Mat(n_eye(rows, cols, type));
return retVal;
}
//
// C++: static Mat Mat::eye(Size size, int type)
//
// javadoc: Mat::eye(size, type)
public static Mat eye(Size size, int type)
{
Mat retVal = new Mat(n_eye(size.width, size.height, type));
return retVal;
}
//
// C++: Mat Mat::inv(int method = DECOMP_LU)
//
// javadoc: Mat::inv(method)
public Mat inv(int method)
{
Mat retVal = new Mat(n_inv(nativeObj, method));
return retVal;
}
// javadoc: Mat::inv()
public Mat inv()
{
Mat retVal = new Mat(n_inv(nativeObj));
return retVal;
}
//
// C++: bool Mat::isContinuous()
//
// javadoc: Mat::isContinuous()
public boolean isContinuous()
{
boolean retVal = n_isContinuous(nativeObj);
return retVal;
}
//
// C++: bool Mat::isSubmatrix()
//
// javadoc: Mat::isSubmatrix()
public boolean isSubmatrix()
{
boolean retVal = n_isSubmatrix(nativeObj);
return retVal;
}
//
// C++: void Mat::locateROI(Size wholeSize, Point ofs)
//
// javadoc: Mat::locateROI(wholeSize, ofs)
public void locateROI(Size wholeSize, Point ofs)
{
double[] wholeSize_out = new double[2];
double[] ofs_out = new double[2];
locateROI_0(nativeObj, wholeSize_out, ofs_out);
if(wholeSize!=null){ wholeSize.width = wholeSize_out[0]; wholeSize.height = wholeSize_out[1]; }
if(ofs!=null){ ofs.x = ofs_out[0]; ofs.y = ofs_out[1]; }
return;
}
//
// C++: Mat Mat::mul(Mat m, double scale = 1)
//
// javadoc: Mat::mul(m, scale)
public Mat mul(Mat m, double scale)
{
Mat retVal = new Mat(n_mul(nativeObj, m.nativeObj, scale));
return retVal;
}
// javadoc: Mat::mul(m)
public Mat mul(Mat m)
{
Mat retVal = new Mat(n_mul(nativeObj, m.nativeObj));
return retVal;
}
//
// C++: static Mat Mat::ones(int rows, int cols, int type)
//
// javadoc: Mat::ones(rows, cols, type)
public static Mat ones(int rows, int cols, int type)
{
Mat retVal = new Mat(n_ones(rows, cols, type));
return retVal;
}
//
// C++: static Mat Mat::ones(Size size, int type)
//
// javadoc: Mat::ones(size, type)
public static Mat ones(Size size, int type)
{
Mat retVal = new Mat(n_ones(size.width, size.height, type));
return retVal;
}
//
// C++: void Mat::push_back(Mat m)
//
// javadoc: Mat::push_back(m)
public void push_back(Mat m)
{
n_push_back(nativeObj, m.nativeObj);
return;
}
//
// C++: void Mat::release()
//
// javadoc: Mat::release()
public void release()
{
n_release(nativeObj);
return;
}
//
// C++: Mat Mat::reshape(int cn, int rows = 0)
//
// javadoc: Mat::reshape(cn, rows)
public Mat reshape(int cn, int rows)
{
Mat retVal = new Mat(n_reshape(nativeObj, cn, rows));
return retVal;
}
// javadoc: Mat::reshape(cn)
public Mat reshape(int cn)
{
Mat retVal = new Mat(n_reshape(nativeObj, cn));
return retVal;
}
//
// C++: Mat Mat::row(int y)
//
// javadoc: Mat::row(y)
public Mat row(int y)
{
Mat retVal = new Mat(n_row(nativeObj, y));
return retVal;
}
//
// C++: Mat Mat::rowRange(int startrow, int endrow)
//
// javadoc: Mat::rowRange(startrow, endrow)
public Mat rowRange(int startrow, int endrow)
{
Mat retVal = new Mat(n_rowRange(nativeObj, startrow, endrow));
return retVal;
}
//
// C++: Mat Mat::rowRange(Range r)
//
// javadoc: Mat::rowRange(r)
public Mat rowRange(Range r)
{
Mat retVal = new Mat(n_rowRange(nativeObj, r.start, r.end));
return retVal;
}
//
// C++: int Mat::rows()
//
// javadoc: Mat::rows()
public int rows()
{
int retVal = n_rows(nativeObj);
return retVal;
}
//
// C++: Mat Mat::operator =(Scalar s)
//
// javadoc: Mat::operator =(s)
public Mat setTo(Scalar s)
{
Mat retVal = new Mat(n_setTo(nativeObj, s.val[0], s.val[1], s.val[2], s.val[3]));
return retVal;
}
//
// C++: Mat Mat::setTo(Scalar value, Mat mask = Mat())
//
// javadoc: Mat::setTo(value, mask)
public Mat setTo(Scalar value, Mat mask)
{
Mat retVal = new Mat(n_setTo(nativeObj, value.val[0], value.val[1], value.val[2], value.val[3], mask.nativeObj));
return retVal;
}
//
// C++: Mat Mat::setTo(Mat value, Mat mask = Mat())
//
// javadoc: Mat::setTo(value, mask)
public Mat setTo(Mat value, Mat mask)
{
Mat retVal = new Mat(n_setTo(nativeObj, value.nativeObj, mask.nativeObj));
return retVal;
}
// javadoc: Mat::setTo(value)
public Mat setTo(Mat value)
{
Mat retVal = new Mat(n_setTo(nativeObj, value.nativeObj));
return retVal;
}
//
// C++: Size Mat::size()
//
// javadoc: Mat::size()
public Size size()
{
Size retVal = new Size(n_size(nativeObj));
return retVal;
}
//
// C++: size_t Mat::step1(int i = 0)
//
// javadoc: Mat::step1(i)
public long step1(int i)
{
long retVal = n_step1(nativeObj, i);
return retVal;
}
// javadoc: Mat::step1()
public long step1()
{
long retVal = n_step1(nativeObj);
return retVal;
}
//
// C++: Mat Mat::operator()(int rowStart, int rowEnd, int colStart, int
// colEnd)
//
// javadoc: Mat::operator()(rowStart, rowEnd, colStart, colEnd)
public Mat submat(int rowStart, int rowEnd, int colStart, int colEnd)
{
Mat retVal = new Mat(n_submat_rr(nativeObj, rowStart, rowEnd, colStart, colEnd));
return retVal;
}
//
// C++: Mat Mat::operator()(Range rowRange, Range colRange)
//
// javadoc: Mat::operator()(rowRange, colRange)
public Mat submat(Range rowRange, Range colRange)
{
Mat retVal = new Mat(n_submat_rr(nativeObj, rowRange.start, rowRange.end, colRange.start, colRange.end));
return retVal;
}
//
// C++: Mat Mat::operator()(Rect roi)
//
// javadoc: Mat::operator()(roi)
public Mat submat(Rect roi)
{
Mat retVal = new Mat(n_submat(nativeObj, roi.x, roi.y, roi.width, roi.height));
return retVal;
}
//
// C++: Mat Mat::t()
//
// javadoc: Mat::t()
public Mat t()
{
Mat retVal = new Mat(n_t(nativeObj));
return retVal;
}
//
// C++: size_t Mat::total()
//
// javadoc: Mat::total()
public long total()
{
long retVal = n_total(nativeObj);
return retVal;
}
//
// C++: int Mat::type()
//
// javadoc: Mat::type()
public int type()
{
int retVal = n_type(nativeObj);
return retVal;
}
//
// C++: static Mat Mat::zeros(int rows, int cols, int type)
//
// javadoc: Mat::zeros(rows, cols, type)
public static Mat zeros(int rows, int cols, int type)
{
Mat retVal = new Mat(n_zeros(rows, cols, type));
return retVal;
}
//
// C++: static Mat Mat::zeros(Size size, int type)
//
// javadoc: Mat::zeros(size, type)
public static Mat zeros(Size size, int type)
{
Mat retVal = new Mat(n_zeros(size.width, size.height, type));
return retVal;
}
@Override
protected void finalize() throws Throwable {
n_delete(nativeObj);
super.finalize();
}
// javadoc:Mat::toString()
@Override
public String toString() {
return "Mat [ " +
rows() + "*" + cols() + "*" + CvType.typeToString(type()) +
", isCont=" + isContinuous() + ", isSubmat=" + isSubmatrix() +
", nativeObj=0x" + Long.toHexString(nativeObj) +
", dataAddr=0x" + Long.toHexString(dataAddr()) +
" ]";
}
// javadoc:Mat::dump()
public String dump() {
return nDump(nativeObj);
}
// javadoc:Mat::put(row,col,data)
public int put(int row, int col, double... data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
return nPutD(nativeObj, row, col, data.length, data);
}
// javadoc:Mat::put(row,col,data)
public int put(int row, int col, float[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_32F) {
return nPutF(nativeObj, row, col, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::put(row,col,data)
public int put(int row, int col, int[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_32S) {
return nPutI(nativeObj, row, col, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::put(row,col,data)
public int put(int row, int col, short[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_16U || CvType.depth(t) == CvType.CV_16S) {
return nPutS(nativeObj, row, col, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::put(row,col,data)
public int put(int row, int col, byte[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_8U || CvType.depth(t) == CvType.CV_8S) {
return nPutB(nativeObj, row, col, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::get(row,col,data)
public int get(int row, int col, byte[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_8U || CvType.depth(t) == CvType.CV_8S) {
return nGetB(nativeObj, row, col, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::get(row,col,data)
public int get(int row, int col, short[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_16U || CvType.depth(t) == CvType.CV_16S) {
return nGetS(nativeObj, row, col, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::get(row,col,data)
public int get(int row, int col, int[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_32S) {
return nGetI(nativeObj, row, col, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::get(row,col,data)
public int get(int row, int col, float[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_32F) {
return nGetF(nativeObj, row, col, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::get(row,col,data)
public int get(int row, int col, double[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_64F) {
return nGetD(nativeObj, row, col, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::get(row,col)
public double[] get(int row, int col) {
return nGet(nativeObj, row, col);
}
// javadoc:Mat::height()
public int height() {
return rows();
}
// javadoc:Mat::width()
public int width() {
return cols();
}
// javadoc:Mat::getNativeObjAddr()
public long getNativeObjAddr() {
return nativeObj;
}
// C++: Mat::Mat()
private static native long n_Mat();
// C++: Mat::Mat(int rows, int cols, int type)
private static native long n_Mat(int rows, int cols, int type);
// C++: Mat::Mat(Size size, int type)
private static native long n_Mat(double size_width, double size_height, int type);
// C++: Mat::Mat(int rows, int cols, int type, Scalar s)
private static native long n_Mat(int rows, int cols, int type, double s_val0, double s_val1, double s_val2, double s_val3);
// C++: Mat::Mat(Size size, int type, Scalar s)
private static native long n_Mat(double size_width, double size_height, int type, double s_val0, double s_val1, double s_val2, double s_val3);
// C++: Mat::Mat(Mat m, Range rowRange, Range colRange = Range::all())
private static native long n_Mat(long m_nativeObj, int rowRange_start, int rowRange_end, int colRange_start, int colRange_end);
private static native long n_Mat(long m_nativeObj, int rowRange_start, int rowRange_end);
// C++: Mat Mat::adjustROI(int dtop, int dbottom, int dleft, int dright)
private static native long n_adjustROI(long nativeObj, int dtop, int dbottom, int dleft, int dright);
// C++: void Mat::assignTo(Mat m, int type = -1)
private static native void n_assignTo(long nativeObj, long m_nativeObj, int type);
private static native void n_assignTo(long nativeObj, long m_nativeObj);
// C++: int Mat::channels()
private static native int n_channels(long nativeObj);
// C++: int Mat::checkVector(int elemChannels, int depth = -1, bool
// requireContinuous = true)
private static native int n_checkVector(long nativeObj, int elemChannels, int depth, boolean requireContinuous);
private static native int n_checkVector(long nativeObj, int elemChannels, int depth);
private static native int n_checkVector(long nativeObj, int elemChannels);
// C++: Mat Mat::clone()
private static native long n_clone(long nativeObj);
// C++: Mat Mat::col(int x)
private static native long n_col(long nativeObj, int x);
// C++: Mat Mat::colRange(int startcol, int endcol)
private static native long n_colRange(long nativeObj, int startcol, int endcol);
// C++: int Mat::dims()
private static native int n_dims(long nativeObj);
// C++: int Mat::cols()
private static native int n_cols(long nativeObj);
// C++: void Mat::convertTo(Mat& m, int rtype, double alpha = 1, double beta
// = 0)
private static native void n_convertTo(long nativeObj, long m_nativeObj, int rtype, double alpha, double beta);
private static native void n_convertTo(long nativeObj, long m_nativeObj, int rtype, double alpha);
private static native void n_convertTo(long nativeObj, long m_nativeObj, int rtype);
// C++: void Mat::copyTo(Mat& m)
private static native void n_copyTo(long nativeObj, long m_nativeObj);
// C++: void Mat::copyTo(Mat& m, Mat mask)
private static native void n_copyTo(long nativeObj, long m_nativeObj, long mask_nativeObj);
// C++: void Mat::create(int rows, int cols, int type)
private static native void n_create(long nativeObj, int rows, int cols, int type);
// C++: void Mat::create(Size size, int type)
private static native void n_create(long nativeObj, double size_width, double size_height, int type);
// C++: Mat Mat::cross(Mat m)
private static native long n_cross(long nativeObj, long m_nativeObj);
// C++: long Mat::dataAddr()
private static native long n_dataAddr(long nativeObj);
// C++: int Mat::depth()
private static native int n_depth(long nativeObj);
// C++: Mat Mat::diag(int d = 0)
private static native long n_diag(long nativeObj, int d);
// C++: static Mat Mat::diag(Mat d)
private static native long n_diag(long d_nativeObj);
// C++: double Mat::dot(Mat m)
private static native double n_dot(long nativeObj, long m_nativeObj);
// C++: size_t Mat::elemSize()
private static native long n_elemSize(long nativeObj);
// C++: size_t Mat::elemSize1()
private static native long n_elemSize1(long nativeObj);
// C++: bool Mat::empty()
private static native boolean n_empty(long nativeObj);
// C++: static Mat Mat::eye(int rows, int cols, int type)
private static native long n_eye(int rows, int cols, int type);
// C++: static Mat Mat::eye(Size size, int type)
private static native long n_eye(double size_width, double size_height, int type);
// C++: Mat Mat::inv(int method = DECOMP_LU)
private static native long n_inv(long nativeObj, int method);
private static native long n_inv(long nativeObj);
// C++: bool Mat::isContinuous()
private static native boolean n_isContinuous(long nativeObj);
// C++: bool Mat::isSubmatrix()
private static native boolean n_isSubmatrix(long nativeObj);
// C++: void Mat::locateROI(Size wholeSize, Point ofs)
private static native void locateROI_0(long nativeObj, double[] wholeSize_out, double[] ofs_out);
// C++: Mat Mat::mul(Mat m, double scale = 1)
private static native long n_mul(long nativeObj, long m_nativeObj, double scale);
private static native long n_mul(long nativeObj, long m_nativeObj);
// C++: static Mat Mat::ones(int rows, int cols, int type)
private static native long n_ones(int rows, int cols, int type);
// C++: static Mat Mat::ones(Size size, int type)
private static native long n_ones(double size_width, double size_height, int type);
// C++: void Mat::push_back(Mat m)
private static native void n_push_back(long nativeObj, long m_nativeObj);
// C++: void Mat::release()
private static native void n_release(long nativeObj);
// C++: Mat Mat::reshape(int cn, int rows = 0)
private static native long n_reshape(long nativeObj, int cn, int rows);
private static native long n_reshape(long nativeObj, int cn);
// C++: Mat Mat::row(int y)
private static native long n_row(long nativeObj, int y);
// C++: Mat Mat::rowRange(int startrow, int endrow)
private static native long n_rowRange(long nativeObj, int startrow, int endrow);
// C++: int Mat::rows()
private static native int n_rows(long nativeObj);
// C++: Mat Mat::operator =(Scalar s)
private static native long n_setTo(long nativeObj, double s_val0, double s_val1, double s_val2, double s_val3);
// C++: Mat Mat::setTo(Scalar value, Mat mask = Mat())
private static native long n_setTo(long nativeObj, double s_val0, double s_val1, double s_val2, double s_val3, long mask_nativeObj);
// C++: Mat Mat::setTo(Mat value, Mat mask = Mat())
private static native long n_setTo(long nativeObj, long value_nativeObj, long mask_nativeObj);
private static native long n_setTo(long nativeObj, long value_nativeObj);
// C++: Size Mat::size()
private static native double[] n_size(long nativeObj);
// C++: size_t Mat::step1(int i = 0)
private static native long n_step1(long nativeObj, int i);
private static native long n_step1(long nativeObj);
// C++: Mat Mat::operator()(Range rowRange, Range colRange)
private static native long n_submat_rr(long nativeObj, int rowRange_start, int rowRange_end, int colRange_start, int colRange_end);
// C++: Mat Mat::operator()(Rect roi)
private static native long n_submat(long nativeObj, int roi_x, int roi_y, int roi_width, int roi_height);
// C++: Mat Mat::t()
private static native long n_t(long nativeObj);
// C++: size_t Mat::total()
private static native long n_total(long nativeObj);
// C++: int Mat::type()
private static native int n_type(long nativeObj);
// C++: static Mat Mat::zeros(int rows, int cols, int type)
private static native long n_zeros(int rows, int cols, int type);
// C++: static Mat Mat::zeros(Size size, int type)
private static native long n_zeros(double size_width, double size_height, int type);
// native support for java finalize()
private static native void n_delete(long nativeObj);
private static native int nPutD(long self, int row, int col, int count, double[] data);
private static native int nPutF(long self, int row, int col, int count, float[] data);
private static native int nPutI(long self, int row, int col, int count, int[] data);
private static native int nPutS(long self, int row, int col, int count, short[] data);
private static native int nPutB(long self, int row, int col, int count, byte[] data);
private static native int nGetB(long self, int row, int col, int count, byte[] vals);
private static native int nGetS(long self, int row, int col, int count, short[] vals);
private static native int nGetI(long self, int row, int col, int count, int[] vals);
private static native int nGetF(long self, int row, int col, int count, float[] vals);
private static native int nGetD(long self, int row, int col, int count, double[] vals);
private static native double[] nGet(long self, int row, int col);
private static native String nDump(long self);
}
| 33,993 | 24.811693 | 146 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/Range.java | package org.opencv.core;
//javadoc:Range
public class Range {
public int start, end;
public Range(int s, int e) {
this.start = s;
this.end = e;
}
public Range() {
this(0, 0);
}
public Range(double[] vals) {
set(vals);
}
public void set(double[] vals) {
if (vals != null) {
start = vals.length > 0 ? (int) vals[0] : 0;
end = vals.length > 1 ? (int) vals[1] : 0;
} else {
start = 0;
end = 0;
}
}
public int size() {
return empty() ? 0 : end - start;
}
public boolean empty() {
return end <= start;
}
public static Range all() {
return new Range(Integer.MIN_VALUE, Integer.MAX_VALUE);
}
public Range intersection(Range r1) {
Range r = new Range(Math.max(r1.start, this.start), Math.min(r1.end, this.end));
r.end = Math.max(r.end, r.start);
return r;
}
public Range shift(int delta) {
return new Range(start + delta, end + delta);
}
public Range clone() {
return new Range(start, end);
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
long temp;
temp = Double.doubleToLongBits(start);
result = prime * result + (int) (temp ^ (temp >>> 32));
temp = Double.doubleToLongBits(end);
result = prime * result + (int) (temp ^ (temp >>> 32));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (!(obj instanceof Range)) return false;
Range it = (Range) obj;
return start == it.start && end == it.end;
}
@Override
public String toString() {
return "[" + start + ", " + end + ")";
}
}
| 1,848 | 21.277108 | 88 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/CvException.java | package org.opencv.core;
public class CvException extends RuntimeException {
private static final long serialVersionUID = 1L;
public CvException(String msg) {
super(msg);
}
@Override
public String toString() {
return "CvException [" + super.toString() + "]";
}
}
| 307 | 18.25 | 56 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/MatOfKeyPoint.java | package org.opencv.core;
import java.util.Arrays;
import java.util.List;
import org.opencv.core.KeyPoint;
public class MatOfKeyPoint extends Mat {
// 32FC7
private static final int _depth = CvType.CV_32F;
private static final int _channels = 7;
public MatOfKeyPoint() {
super();
}
protected MatOfKeyPoint(long addr) {
super(addr);
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public static MatOfKeyPoint fromNativeAddr(long addr) {
return new MatOfKeyPoint(addr);
}
public MatOfKeyPoint(Mat m) {
super(m, Range.all());
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public MatOfKeyPoint(KeyPoint...a) {
super();
fromArray(a);
}
public void alloc(int elemNumber) {
if(elemNumber>0)
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
}
public void fromArray(KeyPoint...a) {
if(a==null || a.length==0)
return;
int num = a.length;
alloc(num);
float buff[] = new float[num * _channels];
for(int i=0; i<num; i++) {
KeyPoint kp = a[i];
buff[_channels*i+0] = (float) kp.pt.x;
buff[_channels*i+1] = (float) kp.pt.y;
buff[_channels*i+2] = kp.size;
buff[_channels*i+3] = kp.angle;
buff[_channels*i+4] = kp.response;
buff[_channels*i+5] = kp.octave;
buff[_channels*i+6] = kp.class_id;
}
put(0, 0, buff); //TODO: check ret val!
}
public KeyPoint[] toArray() {
int num = (int) total();
KeyPoint[] a = new KeyPoint[num];
if(num == 0)
return a;
float buff[] = new float[num * _channels];
get(0, 0, buff); //TODO: check ret val!
for(int i=0; i<num; i++)
a[i] = new KeyPoint( buff[_channels*i+0], buff[_channels*i+1], buff[_channels*i+2], buff[_channels*i+3],
buff[_channels*i+4], (int) buff[_channels*i+5], (int) buff[_channels*i+6] );
return a;
}
public void fromList(List<KeyPoint> lkp) {
KeyPoint akp[] = lkp.toArray(new KeyPoint[0]);
fromArray(akp);
}
public List<KeyPoint> toList() {
KeyPoint[] akp = toArray();
return Arrays.asList(akp);
}
}
| 2,585 | 28.724138 | 116 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/Core.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.core;
import java.lang.String;
import java.util.ArrayList;
import java.util.List;
import org.opencv.core.Mat;
import org.opencv.core.MatOfDouble;
import org.opencv.core.MatOfInt;
import org.opencv.core.Scalar;
import org.opencv.core.TermCriteria;
import org.opencv.utils.Converters;
public class Core {
// these constants are wrapped inside functions to prevent inlining
private static String getVersion() { return "3.1.0"; }
private static String getNativeLibraryName() { return "opencv_java310"; }
private static int getVersionMajor() { return 3; }
private static int getVersionMinor() { return 1; }
private static int getVersionRevision() { return 0; }
private static String getVersionStatus() { return ""; }
public static final String VERSION = getVersion();
public static final String NATIVE_LIBRARY_NAME = getNativeLibraryName();
public static final int VERSION_MAJOR = getVersionMajor();
public static final int VERSION_MINOR = getVersionMinor();
public static final int VERSION_REVISION = getVersionRevision();
public static final String VERSION_STATUS = getVersionStatus();
private static final int
CV_8U = 0,
CV_8S = 1,
CV_16U = 2,
CV_16S = 3,
CV_32S = 4,
CV_32F = 5,
CV_64F = 6,
CV_USRTYPE1 = 7;
public static final int
SVD_MODIFY_A = 1,
SVD_NO_UV = 2,
SVD_FULL_UV = 4,
FILLED = -1,
REDUCE_SUM = 0,
REDUCE_AVG = 1,
REDUCE_MAX = 2,
REDUCE_MIN = 3,
StsOk = 0,
StsBackTrace = -1,
StsError = -2,
StsInternal = -3,
StsNoMem = -4,
StsBadArg = -5,
StsBadFunc = -6,
StsNoConv = -7,
StsAutoTrace = -8,
HeaderIsNull = -9,
BadImageSize = -10,
BadOffset = -11,
BadDataPtr = -12,
BadStep = -13,
BadModelOrChSeq = -14,
BadNumChannels = -15,
BadNumChannel1U = -16,
BadDepth = -17,
BadAlphaChannel = -18,
BadOrder = -19,
BadOrigin = -20,
BadAlign = -21,
BadCallBack = -22,
BadTileSize = -23,
BadCOI = -24,
BadROISize = -25,
MaskIsTiled = -26,
StsNullPtr = -27,
StsVecLengthErr = -28,
StsFilterStructContentErr = -29,
StsKernelStructContentErr = -30,
StsFilterOffsetErr = -31,
StsBadSize = -201,
StsDivByZero = -202,
StsInplaceNotSupported = -203,
StsObjectNotFound = -204,
StsUnmatchedFormats = -205,
StsBadFlag = -206,
StsBadPoint = -207,
StsBadMask = -208,
StsUnmatchedSizes = -209,
StsUnsupportedFormat = -210,
StsOutOfRange = -211,
StsParseError = -212,
StsNotImplemented = -213,
StsBadMemBlock = -214,
StsAssert = -215,
GpuNotSupported = -216,
GpuApiCallError = -217,
OpenGlNotSupported = -218,
OpenGlApiCallError = -219,
OpenCLApiCallError = -220,
OpenCLDoubleNotSupported = -221,
OpenCLInitError = -222,
OpenCLNoAMDBlasFft = -223,
DECOMP_LU = 0,
DECOMP_SVD = 1,
DECOMP_EIG = 2,
DECOMP_CHOLESKY = 3,
DECOMP_QR = 4,
DECOMP_NORMAL = 16,
NORM_INF = 1,
NORM_L1 = 2,
NORM_L2 = 4,
NORM_L2SQR = 5,
NORM_HAMMING = 6,
NORM_HAMMING2 = 7,
NORM_TYPE_MASK = 7,
NORM_RELATIVE = 8,
NORM_MINMAX = 32,
CMP_EQ = 0,
CMP_GT = 1,
CMP_GE = 2,
CMP_LT = 3,
CMP_LE = 4,
CMP_NE = 5,
GEMM_1_T = 1,
GEMM_2_T = 2,
GEMM_3_T = 4,
DFT_INVERSE = 1,
DFT_SCALE = 2,
DFT_ROWS = 4,
DFT_COMPLEX_OUTPUT = 16,
DFT_REAL_OUTPUT = 32,
DCT_INVERSE = DFT_INVERSE,
DCT_ROWS = DFT_ROWS,
BORDER_CONSTANT = 0,
BORDER_REPLICATE = 1,
BORDER_REFLECT = 2,
BORDER_WRAP = 3,
BORDER_REFLECT_101 = 4,
BORDER_TRANSPARENT = 5,
BORDER_REFLECT101 = BORDER_REFLECT_101,
BORDER_DEFAULT = BORDER_REFLECT_101,
BORDER_ISOLATED = 16,
SORT_EVERY_ROW = 0,
SORT_EVERY_COLUMN = 1,
SORT_ASCENDING = 0,
SORT_DESCENDING = 16,
COVAR_SCRAMBLED = 0,
COVAR_NORMAL = 1,
COVAR_USE_AVG = 2,
COVAR_SCALE = 4,
COVAR_ROWS = 8,
COVAR_COLS = 16,
KMEANS_RANDOM_CENTERS = 0,
KMEANS_PP_CENTERS = 2,
KMEANS_USE_INITIAL_LABELS = 1,
LINE_4 = 4,
LINE_8 = 8,
LINE_AA = 16,
FONT_HERSHEY_SIMPLEX = 0,
FONT_HERSHEY_PLAIN = 1,
FONT_HERSHEY_DUPLEX = 2,
FONT_HERSHEY_COMPLEX = 3,
FONT_HERSHEY_TRIPLEX = 4,
FONT_HERSHEY_COMPLEX_SMALL = 5,
FONT_HERSHEY_SCRIPT_SIMPLEX = 6,
FONT_HERSHEY_SCRIPT_COMPLEX = 7,
FONT_ITALIC = 16;
//
// C++: Scalar mean(Mat src, Mat mask = Mat())
//
//javadoc: mean(src, mask)
public static Scalar mean(Mat src, Mat mask)
{
Scalar retVal = new Scalar(mean_0(src.nativeObj, mask.nativeObj));
return retVal;
}
//javadoc: mean(src)
public static Scalar mean(Mat src)
{
Scalar retVal = new Scalar(mean_1(src.nativeObj));
return retVal;
}
//
// C++: Scalar sum(Mat src)
//
//javadoc: sum(src)
public static Scalar sumElems(Mat src)
{
Scalar retVal = new Scalar(sumElems_0(src.nativeObj));
return retVal;
}
//
// C++: Scalar trace(Mat mtx)
//
//javadoc: trace(mtx)
public static Scalar trace(Mat mtx)
{
Scalar retVal = new Scalar(trace_0(mtx.nativeObj));
return retVal;
}
//
// C++: String getBuildInformation()
//
//javadoc: getBuildInformation()
public static String getBuildInformation()
{
String retVal = getBuildInformation_0();
return retVal;
}
//
// C++: bool checkRange(Mat a, bool quiet = true, _hidden_ * pos = 0, double minVal = -DBL_MAX, double maxVal = DBL_MAX)
//
//javadoc: checkRange(a, quiet, minVal, maxVal)
public static boolean checkRange(Mat a, boolean quiet, double minVal, double maxVal)
{
boolean retVal = checkRange_0(a.nativeObj, quiet, minVal, maxVal);
return retVal;
}
//javadoc: checkRange(a)
public static boolean checkRange(Mat a)
{
boolean retVal = checkRange_1(a.nativeObj);
return retVal;
}
//
// C++: bool eigen(Mat src, Mat& eigenvalues, Mat& eigenvectors = Mat())
//
//javadoc: eigen(src, eigenvalues, eigenvectors)
public static boolean eigen(Mat src, Mat eigenvalues, Mat eigenvectors)
{
boolean retVal = eigen_0(src.nativeObj, eigenvalues.nativeObj, eigenvectors.nativeObj);
return retVal;
}
//javadoc: eigen(src, eigenvalues)
public static boolean eigen(Mat src, Mat eigenvalues)
{
boolean retVal = eigen_1(src.nativeObj, eigenvalues.nativeObj);
return retVal;
}
//
// C++: bool solve(Mat src1, Mat src2, Mat& dst, int flags = DECOMP_LU)
//
//javadoc: solve(src1, src2, dst, flags)
public static boolean solve(Mat src1, Mat src2, Mat dst, int flags)
{
boolean retVal = solve_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, flags);
return retVal;
}
//javadoc: solve(src1, src2, dst)
public static boolean solve(Mat src1, Mat src2, Mat dst)
{
boolean retVal = solve_1(src1.nativeObj, src2.nativeObj, dst.nativeObj);
return retVal;
}
//
// C++: double Mahalanobis(Mat v1, Mat v2, Mat icovar)
//
//javadoc: Mahalanobis(v1, v2, icovar)
public static double Mahalanobis(Mat v1, Mat v2, Mat icovar)
{
double retVal = Mahalanobis_0(v1.nativeObj, v2.nativeObj, icovar.nativeObj);
return retVal;
}
//
// C++: double PSNR(Mat src1, Mat src2)
//
//javadoc: PSNR(src1, src2)
public static double PSNR(Mat src1, Mat src2)
{
double retVal = PSNR_0(src1.nativeObj, src2.nativeObj);
return retVal;
}
//
// C++: double determinant(Mat mtx)
//
//javadoc: determinant(mtx)
public static double determinant(Mat mtx)
{
double retVal = determinant_0(mtx.nativeObj);
return retVal;
}
//
// C++: double getTickFrequency()
//
//javadoc: getTickFrequency()
public static double getTickFrequency()
{
double retVal = getTickFrequency_0();
return retVal;
}
//
// C++: double invert(Mat src, Mat& dst, int flags = DECOMP_LU)
//
//javadoc: invert(src, dst, flags)
public static double invert(Mat src, Mat dst, int flags)
{
double retVal = invert_0(src.nativeObj, dst.nativeObj, flags);
return retVal;
}
//javadoc: invert(src, dst)
public static double invert(Mat src, Mat dst)
{
double retVal = invert_1(src.nativeObj, dst.nativeObj);
return retVal;
}
//
// C++: double kmeans(Mat data, int K, Mat& bestLabels, TermCriteria criteria, int attempts, int flags, Mat& centers = Mat())
//
//javadoc: kmeans(data, K, bestLabels, criteria, attempts, flags, centers)
public static double kmeans(Mat data, int K, Mat bestLabels, TermCriteria criteria, int attempts, int flags, Mat centers)
{
double retVal = kmeans_0(data.nativeObj, K, bestLabels.nativeObj, criteria.type, criteria.maxCount, criteria.epsilon, attempts, flags, centers.nativeObj);
return retVal;
}
//javadoc: kmeans(data, K, bestLabels, criteria, attempts, flags)
public static double kmeans(Mat data, int K, Mat bestLabels, TermCriteria criteria, int attempts, int flags)
{
double retVal = kmeans_1(data.nativeObj, K, bestLabels.nativeObj, criteria.type, criteria.maxCount, criteria.epsilon, attempts, flags);
return retVal;
}
//
// C++: double norm(Mat src1, Mat src2, int normType = NORM_L2, Mat mask = Mat())
//
//javadoc: norm(src1, src2, normType, mask)
public static double norm(Mat src1, Mat src2, int normType, Mat mask)
{
double retVal = norm_0(src1.nativeObj, src2.nativeObj, normType, mask.nativeObj);
return retVal;
}
//javadoc: norm(src1, src2, normType)
public static double norm(Mat src1, Mat src2, int normType)
{
double retVal = norm_1(src1.nativeObj, src2.nativeObj, normType);
return retVal;
}
//javadoc: norm(src1, src2)
public static double norm(Mat src1, Mat src2)
{
double retVal = norm_2(src1.nativeObj, src2.nativeObj);
return retVal;
}
//
// C++: double norm(Mat src1, int normType = NORM_L2, Mat mask = Mat())
//
//javadoc: norm(src1, normType, mask)
public static double norm(Mat src1, int normType, Mat mask)
{
double retVal = norm_3(src1.nativeObj, normType, mask.nativeObj);
return retVal;
}
//javadoc: norm(src1, normType)
public static double norm(Mat src1, int normType)
{
double retVal = norm_4(src1.nativeObj, normType);
return retVal;
}
//javadoc: norm(src1)
public static double norm(Mat src1)
{
double retVal = norm_5(src1.nativeObj);
return retVal;
}
//
// C++: double solvePoly(Mat coeffs, Mat& roots, int maxIters = 300)
//
//javadoc: solvePoly(coeffs, roots, maxIters)
public static double solvePoly(Mat coeffs, Mat roots, int maxIters)
{
double retVal = solvePoly_0(coeffs.nativeObj, roots.nativeObj, maxIters);
return retVal;
}
//javadoc: solvePoly(coeffs, roots)
public static double solvePoly(Mat coeffs, Mat roots)
{
double retVal = solvePoly_1(coeffs.nativeObj, roots.nativeObj);
return retVal;
}
//
// C++: float cubeRoot(float val)
//
//javadoc: cubeRoot(val)
public static float cubeRoot(float val)
{
float retVal = cubeRoot_0(val);
return retVal;
}
//
// C++: float fastAtan2(float y, float x)
//
//javadoc: fastAtan2(y, x)
public static float fastAtan2(float y, float x)
{
float retVal = fastAtan2_0(y, x);
return retVal;
}
//
// C++: int borderInterpolate(int p, int len, int borderType)
//
//javadoc: borderInterpolate(p, len, borderType)
public static int borderInterpolate(int p, int len, int borderType)
{
int retVal = borderInterpolate_0(p, len, borderType);
return retVal;
}
//
// C++: int countNonZero(Mat src)
//
//javadoc: countNonZero(src)
public static int countNonZero(Mat src)
{
int retVal = countNonZero_0(src.nativeObj);
return retVal;
}
//
// C++: int getNumThreads()
//
//javadoc: getNumThreads()
public static int getNumThreads()
{
int retVal = getNumThreads_0();
return retVal;
}
//
// C++: int getNumberOfCPUs()
//
//javadoc: getNumberOfCPUs()
public static int getNumberOfCPUs()
{
int retVal = getNumberOfCPUs_0();
return retVal;
}
//
// C++: int getOptimalDFTSize(int vecsize)
//
//javadoc: getOptimalDFTSize(vecsize)
public static int getOptimalDFTSize(int vecsize)
{
int retVal = getOptimalDFTSize_0(vecsize);
return retVal;
}
//
// C++: int getThreadNum()
//
//javadoc: getThreadNum()
public static int getThreadNum()
{
int retVal = getThreadNum_0();
return retVal;
}
//
// C++: int solveCubic(Mat coeffs, Mat& roots)
//
//javadoc: solveCubic(coeffs, roots)
public static int solveCubic(Mat coeffs, Mat roots)
{
int retVal = solveCubic_0(coeffs.nativeObj, roots.nativeObj);
return retVal;
}
//
// C++: int64 getCPUTickCount()
//
//javadoc: getCPUTickCount()
public static long getCPUTickCount()
{
long retVal = getCPUTickCount_0();
return retVal;
}
//
// C++: int64 getTickCount()
//
//javadoc: getTickCount()
public static long getTickCount()
{
long retVal = getTickCount_0();
return retVal;
}
//
// C++: void LUT(Mat src, Mat lut, Mat& dst)
//
//javadoc: LUT(src, lut, dst)
public static void LUT(Mat src, Mat lut, Mat dst)
{
LUT_0(src.nativeObj, lut.nativeObj, dst.nativeObj);
return;
}
//
// C++: void PCABackProject(Mat data, Mat mean, Mat eigenvectors, Mat& result)
//
//javadoc: PCABackProject(data, mean, eigenvectors, result)
public static void PCABackProject(Mat data, Mat mean, Mat eigenvectors, Mat result)
{
PCABackProject_0(data.nativeObj, mean.nativeObj, eigenvectors.nativeObj, result.nativeObj);
return;
}
//
// C++: void PCACompute(Mat data, Mat& mean, Mat& eigenvectors, double retainedVariance)
//
//javadoc: PCACompute(data, mean, eigenvectors, retainedVariance)
public static void PCACompute(Mat data, Mat mean, Mat eigenvectors, double retainedVariance)
{
PCACompute_0(data.nativeObj, mean.nativeObj, eigenvectors.nativeObj, retainedVariance);
return;
}
//
// C++: void PCACompute(Mat data, Mat& mean, Mat& eigenvectors, int maxComponents = 0)
//
//javadoc: PCACompute(data, mean, eigenvectors, maxComponents)
public static void PCACompute(Mat data, Mat mean, Mat eigenvectors, int maxComponents)
{
PCACompute_1(data.nativeObj, mean.nativeObj, eigenvectors.nativeObj, maxComponents);
return;
}
//javadoc: PCACompute(data, mean, eigenvectors)
public static void PCACompute(Mat data, Mat mean, Mat eigenvectors)
{
PCACompute_2(data.nativeObj, mean.nativeObj, eigenvectors.nativeObj);
return;
}
//
// C++: void PCAProject(Mat data, Mat mean, Mat eigenvectors, Mat& result)
//
//javadoc: PCAProject(data, mean, eigenvectors, result)
public static void PCAProject(Mat data, Mat mean, Mat eigenvectors, Mat result)
{
PCAProject_0(data.nativeObj, mean.nativeObj, eigenvectors.nativeObj, result.nativeObj);
return;
}
//
// C++: void SVBackSubst(Mat w, Mat u, Mat vt, Mat rhs, Mat& dst)
//
//javadoc: SVBackSubst(w, u, vt, rhs, dst)
public static void SVBackSubst(Mat w, Mat u, Mat vt, Mat rhs, Mat dst)
{
SVBackSubst_0(w.nativeObj, u.nativeObj, vt.nativeObj, rhs.nativeObj, dst.nativeObj);
return;
}
//
// C++: void SVDecomp(Mat src, Mat& w, Mat& u, Mat& vt, int flags = 0)
//
//javadoc: SVDecomp(src, w, u, vt, flags)
public static void SVDecomp(Mat src, Mat w, Mat u, Mat vt, int flags)
{
SVDecomp_0(src.nativeObj, w.nativeObj, u.nativeObj, vt.nativeObj, flags);
return;
}
//javadoc: SVDecomp(src, w, u, vt)
public static void SVDecomp(Mat src, Mat w, Mat u, Mat vt)
{
SVDecomp_1(src.nativeObj, w.nativeObj, u.nativeObj, vt.nativeObj);
return;
}
//
// C++: void absdiff(Mat src1, Mat src2, Mat& dst)
//
//javadoc: absdiff(src1, src2, dst)
public static void absdiff(Mat src1, Mat src2, Mat dst)
{
absdiff_0(src1.nativeObj, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void absdiff(Mat src1, Scalar src2, Mat& dst)
//
//javadoc: absdiff(src1, src2, dst)
public static void absdiff(Mat src1, Scalar src2, Mat dst)
{
absdiff_1(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj);
return;
}
//
// C++: void add(Mat src1, Mat src2, Mat& dst, Mat mask = Mat(), int dtype = -1)
//
//javadoc: add(src1, src2, dst, mask, dtype)
public static void add(Mat src1, Mat src2, Mat dst, Mat mask, int dtype)
{
add_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj, dtype);
return;
}
//javadoc: add(src1, src2, dst, mask)
public static void add(Mat src1, Mat src2, Mat dst, Mat mask)
{
add_1(src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj);
return;
}
//javadoc: add(src1, src2, dst)
public static void add(Mat src1, Mat src2, Mat dst)
{
add_2(src1.nativeObj, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void add(Mat src1, Scalar src2, Mat& dst, Mat mask = Mat(), int dtype = -1)
//
//javadoc: add(src1, src2, dst, mask, dtype)
public static void add(Mat src1, Scalar src2, Mat dst, Mat mask, int dtype)
{
add_3(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, mask.nativeObj, dtype);
return;
}
//javadoc: add(src1, src2, dst, mask)
public static void add(Mat src1, Scalar src2, Mat dst, Mat mask)
{
add_4(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, mask.nativeObj);
return;
}
//javadoc: add(src1, src2, dst)
public static void add(Mat src1, Scalar src2, Mat dst)
{
add_5(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj);
return;
}
//
// C++: void addWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat& dst, int dtype = -1)
//
//javadoc: addWeighted(src1, alpha, src2, beta, gamma, dst, dtype)
public static void addWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat dst, int dtype)
{
addWeighted_0(src1.nativeObj, alpha, src2.nativeObj, beta, gamma, dst.nativeObj, dtype);
return;
}
//javadoc: addWeighted(src1, alpha, src2, beta, gamma, dst)
public static void addWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat dst)
{
addWeighted_1(src1.nativeObj, alpha, src2.nativeObj, beta, gamma, dst.nativeObj);
return;
}
//
// C++: void batchDistance(Mat src1, Mat src2, Mat& dist, int dtype, Mat& nidx, int normType = NORM_L2, int K = 0, Mat mask = Mat(), int update = 0, bool crosscheck = false)
//
//javadoc: batchDistance(src1, src2, dist, dtype, nidx, normType, K, mask, update, crosscheck)
public static void batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K, Mat mask, int update, boolean crosscheck)
{
batchDistance_0(src1.nativeObj, src2.nativeObj, dist.nativeObj, dtype, nidx.nativeObj, normType, K, mask.nativeObj, update, crosscheck);
return;
}
//javadoc: batchDistance(src1, src2, dist, dtype, nidx, normType, K)
public static void batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K)
{
batchDistance_1(src1.nativeObj, src2.nativeObj, dist.nativeObj, dtype, nidx.nativeObj, normType, K);
return;
}
//javadoc: batchDistance(src1, src2, dist, dtype, nidx)
public static void batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx)
{
batchDistance_2(src1.nativeObj, src2.nativeObj, dist.nativeObj, dtype, nidx.nativeObj);
return;
}
//
// C++: void bitwise_and(Mat src1, Mat src2, Mat& dst, Mat mask = Mat())
//
//javadoc: bitwise_and(src1, src2, dst, mask)
public static void bitwise_and(Mat src1, Mat src2, Mat dst, Mat mask)
{
bitwise_and_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj);
return;
}
//javadoc: bitwise_and(src1, src2, dst)
public static void bitwise_and(Mat src1, Mat src2, Mat dst)
{
bitwise_and_1(src1.nativeObj, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void bitwise_not(Mat src, Mat& dst, Mat mask = Mat())
//
//javadoc: bitwise_not(src, dst, mask)
public static void bitwise_not(Mat src, Mat dst, Mat mask)
{
bitwise_not_0(src.nativeObj, dst.nativeObj, mask.nativeObj);
return;
}
//javadoc: bitwise_not(src, dst)
public static void bitwise_not(Mat src, Mat dst)
{
bitwise_not_1(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void bitwise_or(Mat src1, Mat src2, Mat& dst, Mat mask = Mat())
//
//javadoc: bitwise_or(src1, src2, dst, mask)
public static void bitwise_or(Mat src1, Mat src2, Mat dst, Mat mask)
{
bitwise_or_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj);
return;
}
//javadoc: bitwise_or(src1, src2, dst)
public static void bitwise_or(Mat src1, Mat src2, Mat dst)
{
bitwise_or_1(src1.nativeObj, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void bitwise_xor(Mat src1, Mat src2, Mat& dst, Mat mask = Mat())
//
//javadoc: bitwise_xor(src1, src2, dst, mask)
public static void bitwise_xor(Mat src1, Mat src2, Mat dst, Mat mask)
{
bitwise_xor_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj);
return;
}
//javadoc: bitwise_xor(src1, src2, dst)
public static void bitwise_xor(Mat src1, Mat src2, Mat dst)
{
bitwise_xor_1(src1.nativeObj, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void calcCovarMatrix(Mat samples, Mat& covar, Mat& mean, int flags, int ctype = CV_64F)
//
//javadoc: calcCovarMatrix(samples, covar, mean, flags, ctype)
public static void calcCovarMatrix(Mat samples, Mat covar, Mat mean, int flags, int ctype)
{
calcCovarMatrix_0(samples.nativeObj, covar.nativeObj, mean.nativeObj, flags, ctype);
return;
}
//javadoc: calcCovarMatrix(samples, covar, mean, flags)
public static void calcCovarMatrix(Mat samples, Mat covar, Mat mean, int flags)
{
calcCovarMatrix_1(samples.nativeObj, covar.nativeObj, mean.nativeObj, flags);
return;
}
//
// C++: void cartToPolar(Mat x, Mat y, Mat& magnitude, Mat& angle, bool angleInDegrees = false)
//
//javadoc: cartToPolar(x, y, magnitude, angle, angleInDegrees)
public static void cartToPolar(Mat x, Mat y, Mat magnitude, Mat angle, boolean angleInDegrees)
{
cartToPolar_0(x.nativeObj, y.nativeObj, magnitude.nativeObj, angle.nativeObj, angleInDegrees);
return;
}
//javadoc: cartToPolar(x, y, magnitude, angle)
public static void cartToPolar(Mat x, Mat y, Mat magnitude, Mat angle)
{
cartToPolar_1(x.nativeObj, y.nativeObj, magnitude.nativeObj, angle.nativeObj);
return;
}
//
// C++: void compare(Mat src1, Mat src2, Mat& dst, int cmpop)
//
//javadoc: compare(src1, src2, dst, cmpop)
public static void compare(Mat src1, Mat src2, Mat dst, int cmpop)
{
compare_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, cmpop);
return;
}
//
// C++: void compare(Mat src1, Scalar src2, Mat& dst, int cmpop)
//
//javadoc: compare(src1, src2, dst, cmpop)
public static void compare(Mat src1, Scalar src2, Mat dst, int cmpop)
{
compare_1(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, cmpop);
return;
}
//
// C++: void completeSymm(Mat& mtx, bool lowerToUpper = false)
//
//javadoc: completeSymm(mtx, lowerToUpper)
public static void completeSymm(Mat mtx, boolean lowerToUpper)
{
completeSymm_0(mtx.nativeObj, lowerToUpper);
return;
}
//javadoc: completeSymm(mtx)
public static void completeSymm(Mat mtx)
{
completeSymm_1(mtx.nativeObj);
return;
}
//
// C++: void convertScaleAbs(Mat src, Mat& dst, double alpha = 1, double beta = 0)
//
//javadoc: convertScaleAbs(src, dst, alpha, beta)
public static void convertScaleAbs(Mat src, Mat dst, double alpha, double beta)
{
convertScaleAbs_0(src.nativeObj, dst.nativeObj, alpha, beta);
return;
}
//javadoc: convertScaleAbs(src, dst)
public static void convertScaleAbs(Mat src, Mat dst)
{
convertScaleAbs_1(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void copyMakeBorder(Mat src, Mat& dst, int top, int bottom, int left, int right, int borderType, Scalar value = Scalar())
//
//javadoc: copyMakeBorder(src, dst, top, bottom, left, right, borderType, value)
public static void copyMakeBorder(Mat src, Mat dst, int top, int bottom, int left, int right, int borderType, Scalar value)
{
copyMakeBorder_0(src.nativeObj, dst.nativeObj, top, bottom, left, right, borderType, value.val[0], value.val[1], value.val[2], value.val[3]);
return;
}
//javadoc: copyMakeBorder(src, dst, top, bottom, left, right, borderType)
public static void copyMakeBorder(Mat src, Mat dst, int top, int bottom, int left, int right, int borderType)
{
copyMakeBorder_1(src.nativeObj, dst.nativeObj, top, bottom, left, right, borderType);
return;
}
//
// C++: void dct(Mat src, Mat& dst, int flags = 0)
//
//javadoc: dct(src, dst, flags)
public static void dct(Mat src, Mat dst, int flags)
{
dct_0(src.nativeObj, dst.nativeObj, flags);
return;
}
//javadoc: dct(src, dst)
public static void dct(Mat src, Mat dst)
{
dct_1(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void dft(Mat src, Mat& dst, int flags = 0, int nonzeroRows = 0)
//
//javadoc: dft(src, dst, flags, nonzeroRows)
public static void dft(Mat src, Mat dst, int flags, int nonzeroRows)
{
dft_0(src.nativeObj, dst.nativeObj, flags, nonzeroRows);
return;
}
//javadoc: dft(src, dst)
public static void dft(Mat src, Mat dst)
{
dft_1(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void divide(Mat src1, Mat src2, Mat& dst, double scale = 1, int dtype = -1)
//
//javadoc: divide(src1, src2, dst, scale, dtype)
public static void divide(Mat src1, Mat src2, Mat dst, double scale, int dtype)
{
divide_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, scale, dtype);
return;
}
//javadoc: divide(src1, src2, dst, scale)
public static void divide(Mat src1, Mat src2, Mat dst, double scale)
{
divide_1(src1.nativeObj, src2.nativeObj, dst.nativeObj, scale);
return;
}
//javadoc: divide(src1, src2, dst)
public static void divide(Mat src1, Mat src2, Mat dst)
{
divide_2(src1.nativeObj, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void divide(Mat src1, Scalar src2, Mat& dst, double scale = 1, int dtype = -1)
//
//javadoc: divide(src1, src2, dst, scale, dtype)
public static void divide(Mat src1, Scalar src2, Mat dst, double scale, int dtype)
{
divide_3(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, scale, dtype);
return;
}
//javadoc: divide(src1, src2, dst, scale)
public static void divide(Mat src1, Scalar src2, Mat dst, double scale)
{
divide_4(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, scale);
return;
}
//javadoc: divide(src1, src2, dst)
public static void divide(Mat src1, Scalar src2, Mat dst)
{
divide_5(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj);
return;
}
//
// C++: void divide(double scale, Mat src2, Mat& dst, int dtype = -1)
//
//javadoc: divide(scale, src2, dst, dtype)
public static void divide(double scale, Mat src2, Mat dst, int dtype)
{
divide_6(scale, src2.nativeObj, dst.nativeObj, dtype);
return;
}
//javadoc: divide(scale, src2, dst)
public static void divide(double scale, Mat src2, Mat dst)
{
divide_7(scale, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void exp(Mat src, Mat& dst)
//
//javadoc: exp(src, dst)
public static void exp(Mat src, Mat dst)
{
exp_0(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void extractChannel(Mat src, Mat& dst, int coi)
//
//javadoc: extractChannel(src, dst, coi)
public static void extractChannel(Mat src, Mat dst, int coi)
{
extractChannel_0(src.nativeObj, dst.nativeObj, coi);
return;
}
//
// C++: void findNonZero(Mat src, Mat& idx)
//
//javadoc: findNonZero(src, idx)
public static void findNonZero(Mat src, Mat idx)
{
findNonZero_0(src.nativeObj, idx.nativeObj);
return;
}
//
// C++: void flip(Mat src, Mat& dst, int flipCode)
//
//javadoc: flip(src, dst, flipCode)
public static void flip(Mat src, Mat dst, int flipCode)
{
flip_0(src.nativeObj, dst.nativeObj, flipCode);
return;
}
//
// C++: void gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat& dst, int flags = 0)
//
//javadoc: gemm(src1, src2, alpha, src3, beta, dst, flags)
public static void gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst, int flags)
{
gemm_0(src1.nativeObj, src2.nativeObj, alpha, src3.nativeObj, beta, dst.nativeObj, flags);
return;
}
//javadoc: gemm(src1, src2, alpha, src3, beta, dst)
public static void gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst)
{
gemm_1(src1.nativeObj, src2.nativeObj, alpha, src3.nativeObj, beta, dst.nativeObj);
return;
}
//
// C++: void hconcat(vector_Mat src, Mat& dst)
//
//javadoc: hconcat(src, dst)
public static void hconcat(List<Mat> src, Mat dst)
{
Mat src_mat = Converters.vector_Mat_to_Mat(src);
hconcat_0(src_mat.nativeObj, dst.nativeObj);
return;
}
//
// C++: void idct(Mat src, Mat& dst, int flags = 0)
//
//javadoc: idct(src, dst, flags)
public static void idct(Mat src, Mat dst, int flags)
{
idct_0(src.nativeObj, dst.nativeObj, flags);
return;
}
//javadoc: idct(src, dst)
public static void idct(Mat src, Mat dst)
{
idct_1(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void idft(Mat src, Mat& dst, int flags = 0, int nonzeroRows = 0)
//
//javadoc: idft(src, dst, flags, nonzeroRows)
public static void idft(Mat src, Mat dst, int flags, int nonzeroRows)
{
idft_0(src.nativeObj, dst.nativeObj, flags, nonzeroRows);
return;
}
//javadoc: idft(src, dst)
public static void idft(Mat src, Mat dst)
{
idft_1(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void inRange(Mat src, Scalar lowerb, Scalar upperb, Mat& dst)
//
//javadoc: inRange(src, lowerb, upperb, dst)
public static void inRange(Mat src, Scalar lowerb, Scalar upperb, Mat dst)
{
inRange_0(src.nativeObj, lowerb.val[0], lowerb.val[1], lowerb.val[2], lowerb.val[3], upperb.val[0], upperb.val[1], upperb.val[2], upperb.val[3], dst.nativeObj);
return;
}
//
// C++: void insertChannel(Mat src, Mat& dst, int coi)
//
//javadoc: insertChannel(src, dst, coi)
public static void insertChannel(Mat src, Mat dst, int coi)
{
insertChannel_0(src.nativeObj, dst.nativeObj, coi);
return;
}
//
// C++: void log(Mat src, Mat& dst)
//
//javadoc: log(src, dst)
public static void log(Mat src, Mat dst)
{
log_0(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void magnitude(Mat x, Mat y, Mat& magnitude)
//
//javadoc: magnitude(x, y, magnitude)
public static void magnitude(Mat x, Mat y, Mat magnitude)
{
magnitude_0(x.nativeObj, y.nativeObj, magnitude.nativeObj);
return;
}
//
// C++: void max(Mat src1, Mat src2, Mat& dst)
//
//javadoc: max(src1, src2, dst)
public static void max(Mat src1, Mat src2, Mat dst)
{
max_0(src1.nativeObj, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void max(Mat src1, Scalar src2, Mat& dst)
//
//javadoc: max(src1, src2, dst)
public static void max(Mat src1, Scalar src2, Mat dst)
{
max_1(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj);
return;
}
//
// C++: void meanStdDev(Mat src, vector_double& mean, vector_double& stddev, Mat mask = Mat())
//
//javadoc: meanStdDev(src, mean, stddev, mask)
public static void meanStdDev(Mat src, MatOfDouble mean, MatOfDouble stddev, Mat mask)
{
Mat mean_mat = mean;
Mat stddev_mat = stddev;
meanStdDev_0(src.nativeObj, mean_mat.nativeObj, stddev_mat.nativeObj, mask.nativeObj);
return;
}
//javadoc: meanStdDev(src, mean, stddev)
public static void meanStdDev(Mat src, MatOfDouble mean, MatOfDouble stddev)
{
Mat mean_mat = mean;
Mat stddev_mat = stddev;
meanStdDev_1(src.nativeObj, mean_mat.nativeObj, stddev_mat.nativeObj);
return;
}
//
// C++: void merge(vector_Mat mv, Mat& dst)
//
//javadoc: merge(mv, dst)
public static void merge(List<Mat> mv, Mat dst)
{
Mat mv_mat = Converters.vector_Mat_to_Mat(mv);
merge_0(mv_mat.nativeObj, dst.nativeObj);
return;
}
//
// C++: void min(Mat src1, Mat src2, Mat& dst)
//
//javadoc: min(src1, src2, dst)
public static void min(Mat src1, Mat src2, Mat dst)
{
min_0(src1.nativeObj, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void min(Mat src1, Scalar src2, Mat& dst)
//
//javadoc: min(src1, src2, dst)
public static void min(Mat src1, Scalar src2, Mat dst)
{
min_1(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj);
return;
}
//
// C++: void mixChannels(vector_Mat src, vector_Mat dst, vector_int fromTo)
//
//javadoc: mixChannels(src, dst, fromTo)
public static void mixChannels(List<Mat> src, List<Mat> dst, MatOfInt fromTo)
{
Mat src_mat = Converters.vector_Mat_to_Mat(src);
Mat dst_mat = Converters.vector_Mat_to_Mat(dst);
Mat fromTo_mat = fromTo;
mixChannels_0(src_mat.nativeObj, dst_mat.nativeObj, fromTo_mat.nativeObj);
return;
}
//
// C++: void mulSpectrums(Mat a, Mat b, Mat& c, int flags, bool conjB = false)
//
//javadoc: mulSpectrums(a, b, c, flags, conjB)
public static void mulSpectrums(Mat a, Mat b, Mat c, int flags, boolean conjB)
{
mulSpectrums_0(a.nativeObj, b.nativeObj, c.nativeObj, flags, conjB);
return;
}
//javadoc: mulSpectrums(a, b, c, flags)
public static void mulSpectrums(Mat a, Mat b, Mat c, int flags)
{
mulSpectrums_1(a.nativeObj, b.nativeObj, c.nativeObj, flags);
return;
}
//
// C++: void mulTransposed(Mat src, Mat& dst, bool aTa, Mat delta = Mat(), double scale = 1, int dtype = -1)
//
//javadoc: mulTransposed(src, dst, aTa, delta, scale, dtype)
public static void mulTransposed(Mat src, Mat dst, boolean aTa, Mat delta, double scale, int dtype)
{
mulTransposed_0(src.nativeObj, dst.nativeObj, aTa, delta.nativeObj, scale, dtype);
return;
}
//javadoc: mulTransposed(src, dst, aTa, delta, scale)
public static void mulTransposed(Mat src, Mat dst, boolean aTa, Mat delta, double scale)
{
mulTransposed_1(src.nativeObj, dst.nativeObj, aTa, delta.nativeObj, scale);
return;
}
//javadoc: mulTransposed(src, dst, aTa)
public static void mulTransposed(Mat src, Mat dst, boolean aTa)
{
mulTransposed_2(src.nativeObj, dst.nativeObj, aTa);
return;
}
//
// C++: void multiply(Mat src1, Mat src2, Mat& dst, double scale = 1, int dtype = -1)
//
//javadoc: multiply(src1, src2, dst, scale, dtype)
public static void multiply(Mat src1, Mat src2, Mat dst, double scale, int dtype)
{
multiply_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, scale, dtype);
return;
}
//javadoc: multiply(src1, src2, dst, scale)
public static void multiply(Mat src1, Mat src2, Mat dst, double scale)
{
multiply_1(src1.nativeObj, src2.nativeObj, dst.nativeObj, scale);
return;
}
//javadoc: multiply(src1, src2, dst)
public static void multiply(Mat src1, Mat src2, Mat dst)
{
multiply_2(src1.nativeObj, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void multiply(Mat src1, Scalar src2, Mat& dst, double scale = 1, int dtype = -1)
//
//javadoc: multiply(src1, src2, dst, scale, dtype)
public static void multiply(Mat src1, Scalar src2, Mat dst, double scale, int dtype)
{
multiply_3(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, scale, dtype);
return;
}
//javadoc: multiply(src1, src2, dst, scale)
public static void multiply(Mat src1, Scalar src2, Mat dst, double scale)
{
multiply_4(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, scale);
return;
}
//javadoc: multiply(src1, src2, dst)
public static void multiply(Mat src1, Scalar src2, Mat dst)
{
multiply_5(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj);
return;
}
//
// C++: void normalize(Mat src, Mat& dst, double alpha = 1, double beta = 0, int norm_type = NORM_L2, int dtype = -1, Mat mask = Mat())
//
//javadoc: normalize(src, dst, alpha, beta, norm_type, dtype, mask)
public static void normalize(Mat src, Mat dst, double alpha, double beta, int norm_type, int dtype, Mat mask)
{
normalize_0(src.nativeObj, dst.nativeObj, alpha, beta, norm_type, dtype, mask.nativeObj);
return;
}
//javadoc: normalize(src, dst, alpha, beta, norm_type, dtype)
public static void normalize(Mat src, Mat dst, double alpha, double beta, int norm_type, int dtype)
{
normalize_1(src.nativeObj, dst.nativeObj, alpha, beta, norm_type, dtype);
return;
}
//javadoc: normalize(src, dst, alpha, beta, norm_type)
public static void normalize(Mat src, Mat dst, double alpha, double beta, int norm_type)
{
normalize_2(src.nativeObj, dst.nativeObj, alpha, beta, norm_type);
return;
}
//javadoc: normalize(src, dst)
public static void normalize(Mat src, Mat dst)
{
normalize_3(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void patchNaNs(Mat& a, double val = 0)
//
//javadoc: patchNaNs(a, val)
public static void patchNaNs(Mat a, double val)
{
patchNaNs_0(a.nativeObj, val);
return;
}
//javadoc: patchNaNs(a)
public static void patchNaNs(Mat a)
{
patchNaNs_1(a.nativeObj);
return;
}
//
// C++: void perspectiveTransform(Mat src, Mat& dst, Mat m)
//
//javadoc: perspectiveTransform(src, dst, m)
public static void perspectiveTransform(Mat src, Mat dst, Mat m)
{
perspectiveTransform_0(src.nativeObj, dst.nativeObj, m.nativeObj);
return;
}
//
// C++: void phase(Mat x, Mat y, Mat& angle, bool angleInDegrees = false)
//
//javadoc: phase(x, y, angle, angleInDegrees)
public static void phase(Mat x, Mat y, Mat angle, boolean angleInDegrees)
{
phase_0(x.nativeObj, y.nativeObj, angle.nativeObj, angleInDegrees);
return;
}
//javadoc: phase(x, y, angle)
public static void phase(Mat x, Mat y, Mat angle)
{
phase_1(x.nativeObj, y.nativeObj, angle.nativeObj);
return;
}
//
// C++: void polarToCart(Mat magnitude, Mat angle, Mat& x, Mat& y, bool angleInDegrees = false)
//
//javadoc: polarToCart(magnitude, angle, x, y, angleInDegrees)
public static void polarToCart(Mat magnitude, Mat angle, Mat x, Mat y, boolean angleInDegrees)
{
polarToCart_0(magnitude.nativeObj, angle.nativeObj, x.nativeObj, y.nativeObj, angleInDegrees);
return;
}
//javadoc: polarToCart(magnitude, angle, x, y)
public static void polarToCart(Mat magnitude, Mat angle, Mat x, Mat y)
{
polarToCart_1(magnitude.nativeObj, angle.nativeObj, x.nativeObj, y.nativeObj);
return;
}
//
// C++: void pow(Mat src, double power, Mat& dst)
//
//javadoc: pow(src, power, dst)
public static void pow(Mat src, double power, Mat dst)
{
pow_0(src.nativeObj, power, dst.nativeObj);
return;
}
//
// C++: void randShuffle(Mat& dst, double iterFactor = 1., RNG* rng = 0)
//
//javadoc: randShuffle(dst, iterFactor)
public static void randShuffle(Mat dst, double iterFactor)
{
randShuffle_0(dst.nativeObj, iterFactor);
return;
}
//javadoc: randShuffle(dst)
public static void randShuffle(Mat dst)
{
randShuffle_1(dst.nativeObj);
return;
}
//
// C++: void randn(Mat& dst, double mean, double stddev)
//
//javadoc: randn(dst, mean, stddev)
public static void randn(Mat dst, double mean, double stddev)
{
randn_0(dst.nativeObj, mean, stddev);
return;
}
//
// C++: void randu(Mat& dst, double low, double high)
//
//javadoc: randu(dst, low, high)
public static void randu(Mat dst, double low, double high)
{
randu_0(dst.nativeObj, low, high);
return;
}
//
// C++: void reduce(Mat src, Mat& dst, int dim, int rtype, int dtype = -1)
//
//javadoc: reduce(src, dst, dim, rtype, dtype)
public static void reduce(Mat src, Mat dst, int dim, int rtype, int dtype)
{
reduce_0(src.nativeObj, dst.nativeObj, dim, rtype, dtype);
return;
}
//javadoc: reduce(src, dst, dim, rtype)
public static void reduce(Mat src, Mat dst, int dim, int rtype)
{
reduce_1(src.nativeObj, dst.nativeObj, dim, rtype);
return;
}
//
// C++: void repeat(Mat src, int ny, int nx, Mat& dst)
//
//javadoc: repeat(src, ny, nx, dst)
public static void repeat(Mat src, int ny, int nx, Mat dst)
{
repeat_0(src.nativeObj, ny, nx, dst.nativeObj);
return;
}
//
// C++: void scaleAdd(Mat src1, double alpha, Mat src2, Mat& dst)
//
//javadoc: scaleAdd(src1, alpha, src2, dst)
public static void scaleAdd(Mat src1, double alpha, Mat src2, Mat dst)
{
scaleAdd_0(src1.nativeObj, alpha, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void setErrorVerbosity(bool verbose)
//
//javadoc: setErrorVerbosity(verbose)
public static void setErrorVerbosity(boolean verbose)
{
setErrorVerbosity_0(verbose);
return;
}
//
// C++: void setIdentity(Mat& mtx, Scalar s = Scalar(1))
//
//javadoc: setIdentity(mtx, s)
public static void setIdentity(Mat mtx, Scalar s)
{
setIdentity_0(mtx.nativeObj, s.val[0], s.val[1], s.val[2], s.val[3]);
return;
}
//javadoc: setIdentity(mtx)
public static void setIdentity(Mat mtx)
{
setIdentity_1(mtx.nativeObj);
return;
}
//
// C++: void setNumThreads(int nthreads)
//
//javadoc: setNumThreads(nthreads)
public static void setNumThreads(int nthreads)
{
setNumThreads_0(nthreads);
return;
}
//
// C++: void sort(Mat src, Mat& dst, int flags)
//
//javadoc: sort(src, dst, flags)
public static void sort(Mat src, Mat dst, int flags)
{
sort_0(src.nativeObj, dst.nativeObj, flags);
return;
}
//
// C++: void sortIdx(Mat src, Mat& dst, int flags)
//
//javadoc: sortIdx(src, dst, flags)
public static void sortIdx(Mat src, Mat dst, int flags)
{
sortIdx_0(src.nativeObj, dst.nativeObj, flags);
return;
}
//
// C++: void split(Mat m, vector_Mat& mv)
//
//javadoc: split(m, mv)
public static void split(Mat m, List<Mat> mv)
{
Mat mv_mat = new Mat();
split_0(m.nativeObj, mv_mat.nativeObj);
Converters.Mat_to_vector_Mat(mv_mat, mv);
mv_mat.release();
return;
}
//
// C++: void sqrt(Mat src, Mat& dst)
//
//javadoc: sqrt(src, dst)
public static void sqrt(Mat src, Mat dst)
{
sqrt_0(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void subtract(Mat src1, Mat src2, Mat& dst, Mat mask = Mat(), int dtype = -1)
//
//javadoc: subtract(src1, src2, dst, mask, dtype)
public static void subtract(Mat src1, Mat src2, Mat dst, Mat mask, int dtype)
{
subtract_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj, dtype);
return;
}
//javadoc: subtract(src1, src2, dst, mask)
public static void subtract(Mat src1, Mat src2, Mat dst, Mat mask)
{
subtract_1(src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj);
return;
}
//javadoc: subtract(src1, src2, dst)
public static void subtract(Mat src1, Mat src2, Mat dst)
{
subtract_2(src1.nativeObj, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void subtract(Mat src1, Scalar src2, Mat& dst, Mat mask = Mat(), int dtype = -1)
//
//javadoc: subtract(src1, src2, dst, mask, dtype)
public static void subtract(Mat src1, Scalar src2, Mat dst, Mat mask, int dtype)
{
subtract_3(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, mask.nativeObj, dtype);
return;
}
//javadoc: subtract(src1, src2, dst, mask)
public static void subtract(Mat src1, Scalar src2, Mat dst, Mat mask)
{
subtract_4(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, mask.nativeObj);
return;
}
//javadoc: subtract(src1, src2, dst)
public static void subtract(Mat src1, Scalar src2, Mat dst)
{
subtract_5(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj);
return;
}
//
// C++: void transform(Mat src, Mat& dst, Mat m)
//
//javadoc: transform(src, dst, m)
public static void transform(Mat src, Mat dst, Mat m)
{
transform_0(src.nativeObj, dst.nativeObj, m.nativeObj);
return;
}
//
// C++: void transpose(Mat src, Mat& dst)
//
//javadoc: transpose(src, dst)
public static void transpose(Mat src, Mat dst)
{
transpose_0(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void vconcat(vector_Mat src, Mat& dst)
//
//javadoc: vconcat(src, dst)
public static void vconcat(List<Mat> src, Mat dst)
{
Mat src_mat = Converters.vector_Mat_to_Mat(src);
vconcat_0(src_mat.nativeObj, dst.nativeObj);
return;
}
// manual port
public static class MinMaxLocResult {
public double minVal;
public double maxVal;
public Point minLoc;
public Point maxLoc;
public MinMaxLocResult() {
minVal=0; maxVal=0;
minLoc=new Point();
maxLoc=new Point();
}
}
// C++: minMaxLoc(Mat src, double* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0, InputArray mask=noArray())
//javadoc: minMaxLoc(src, mask)
public static MinMaxLocResult minMaxLoc(Mat src, Mat mask) {
MinMaxLocResult res = new MinMaxLocResult();
long maskNativeObj=0;
if (mask != null) {
maskNativeObj=mask.nativeObj;
}
double resarr[] = n_minMaxLocManual(src.nativeObj, maskNativeObj);
res.minVal=resarr[0];
res.maxVal=resarr[1];
res.minLoc.x=resarr[2];
res.minLoc.y=resarr[3];
res.maxLoc.x=resarr[4];
res.maxLoc.y=resarr[5];
return res;
}
//javadoc: minMaxLoc(src)
public static MinMaxLocResult minMaxLoc(Mat src) {
return minMaxLoc(src, null);
}
// C++: Scalar mean(Mat src, Mat mask = Mat())
private static native double[] mean_0(long src_nativeObj, long mask_nativeObj);
private static native double[] mean_1(long src_nativeObj);
// C++: Scalar sum(Mat src)
private static native double[] sumElems_0(long src_nativeObj);
// C++: Scalar trace(Mat mtx)
private static native double[] trace_0(long mtx_nativeObj);
// C++: String getBuildInformation()
private static native String getBuildInformation_0();
// C++: bool checkRange(Mat a, bool quiet = true, _hidden_ * pos = 0, double minVal = -DBL_MAX, double maxVal = DBL_MAX)
private static native boolean checkRange_0(long a_nativeObj, boolean quiet, double minVal, double maxVal);
private static native boolean checkRange_1(long a_nativeObj);
// C++: bool eigen(Mat src, Mat& eigenvalues, Mat& eigenvectors = Mat())
private static native boolean eigen_0(long src_nativeObj, long eigenvalues_nativeObj, long eigenvectors_nativeObj);
private static native boolean eigen_1(long src_nativeObj, long eigenvalues_nativeObj);
// C++: bool solve(Mat src1, Mat src2, Mat& dst, int flags = DECOMP_LU)
private static native boolean solve_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, int flags);
private static native boolean solve_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj);
// C++: double Mahalanobis(Mat v1, Mat v2, Mat icovar)
private static native double Mahalanobis_0(long v1_nativeObj, long v2_nativeObj, long icovar_nativeObj);
// C++: double PSNR(Mat src1, Mat src2)
private static native double PSNR_0(long src1_nativeObj, long src2_nativeObj);
// C++: double determinant(Mat mtx)
private static native double determinant_0(long mtx_nativeObj);
// C++: double getTickFrequency()
private static native double getTickFrequency_0();
// C++: double invert(Mat src, Mat& dst, int flags = DECOMP_LU)
private static native double invert_0(long src_nativeObj, long dst_nativeObj, int flags);
private static native double invert_1(long src_nativeObj, long dst_nativeObj);
// C++: double kmeans(Mat data, int K, Mat& bestLabels, TermCriteria criteria, int attempts, int flags, Mat& centers = Mat())
private static native double kmeans_0(long data_nativeObj, int K, long bestLabels_nativeObj, int criteria_type, int criteria_maxCount, double criteria_epsilon, int attempts, int flags, long centers_nativeObj);
private static native double kmeans_1(long data_nativeObj, int K, long bestLabels_nativeObj, int criteria_type, int criteria_maxCount, double criteria_epsilon, int attempts, int flags);
// C++: double norm(Mat src1, Mat src2, int normType = NORM_L2, Mat mask = Mat())
private static native double norm_0(long src1_nativeObj, long src2_nativeObj, int normType, long mask_nativeObj);
private static native double norm_1(long src1_nativeObj, long src2_nativeObj, int normType);
private static native double norm_2(long src1_nativeObj, long src2_nativeObj);
// C++: double norm(Mat src1, int normType = NORM_L2, Mat mask = Mat())
private static native double norm_3(long src1_nativeObj, int normType, long mask_nativeObj);
private static native double norm_4(long src1_nativeObj, int normType);
private static native double norm_5(long src1_nativeObj);
// C++: double solvePoly(Mat coeffs, Mat& roots, int maxIters = 300)
private static native double solvePoly_0(long coeffs_nativeObj, long roots_nativeObj, int maxIters);
private static native double solvePoly_1(long coeffs_nativeObj, long roots_nativeObj);
// C++: float cubeRoot(float val)
private static native float cubeRoot_0(float val);
// C++: float fastAtan2(float y, float x)
private static native float fastAtan2_0(float y, float x);
// C++: int borderInterpolate(int p, int len, int borderType)
private static native int borderInterpolate_0(int p, int len, int borderType);
// C++: int countNonZero(Mat src)
private static native int countNonZero_0(long src_nativeObj);
// C++: int getNumThreads()
private static native int getNumThreads_0();
// C++: int getNumberOfCPUs()
private static native int getNumberOfCPUs_0();
// C++: int getOptimalDFTSize(int vecsize)
private static native int getOptimalDFTSize_0(int vecsize);
// C++: int getThreadNum()
private static native int getThreadNum_0();
// C++: int solveCubic(Mat coeffs, Mat& roots)
private static native int solveCubic_0(long coeffs_nativeObj, long roots_nativeObj);
// C++: int64 getCPUTickCount()
private static native long getCPUTickCount_0();
// C++: int64 getTickCount()
private static native long getTickCount_0();
// C++: void LUT(Mat src, Mat lut, Mat& dst)
private static native void LUT_0(long src_nativeObj, long lut_nativeObj, long dst_nativeObj);
// C++: void PCABackProject(Mat data, Mat mean, Mat eigenvectors, Mat& result)
private static native void PCABackProject_0(long data_nativeObj, long mean_nativeObj, long eigenvectors_nativeObj, long result_nativeObj);
// C++: void PCACompute(Mat data, Mat& mean, Mat& eigenvectors, double retainedVariance)
private static native void PCACompute_0(long data_nativeObj, long mean_nativeObj, long eigenvectors_nativeObj, double retainedVariance);
// C++: void PCACompute(Mat data, Mat& mean, Mat& eigenvectors, int maxComponents = 0)
private static native void PCACompute_1(long data_nativeObj, long mean_nativeObj, long eigenvectors_nativeObj, int maxComponents);
private static native void PCACompute_2(long data_nativeObj, long mean_nativeObj, long eigenvectors_nativeObj);
// C++: void PCAProject(Mat data, Mat mean, Mat eigenvectors, Mat& result)
private static native void PCAProject_0(long data_nativeObj, long mean_nativeObj, long eigenvectors_nativeObj, long result_nativeObj);
// C++: void SVBackSubst(Mat w, Mat u, Mat vt, Mat rhs, Mat& dst)
private static native void SVBackSubst_0(long w_nativeObj, long u_nativeObj, long vt_nativeObj, long rhs_nativeObj, long dst_nativeObj);
// C++: void SVDecomp(Mat src, Mat& w, Mat& u, Mat& vt, int flags = 0)
private static native void SVDecomp_0(long src_nativeObj, long w_nativeObj, long u_nativeObj, long vt_nativeObj, int flags);
private static native void SVDecomp_1(long src_nativeObj, long w_nativeObj, long u_nativeObj, long vt_nativeObj);
// C++: void absdiff(Mat src1, Mat src2, Mat& dst)
private static native void absdiff_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj);
// C++: void absdiff(Mat src1, Scalar src2, Mat& dst)
private static native void absdiff_1(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj);
// C++: void add(Mat src1, Mat src2, Mat& dst, Mat mask = Mat(), int dtype = -1)
private static native void add_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, long mask_nativeObj, int dtype);
private static native void add_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, long mask_nativeObj);
private static native void add_2(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj);
// C++: void add(Mat src1, Scalar src2, Mat& dst, Mat mask = Mat(), int dtype = -1)
private static native void add_3(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, long mask_nativeObj, int dtype);
private static native void add_4(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, long mask_nativeObj);
private static native void add_5(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj);
// C++: void addWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat& dst, int dtype = -1)
private static native void addWeighted_0(long src1_nativeObj, double alpha, long src2_nativeObj, double beta, double gamma, long dst_nativeObj, int dtype);
private static native void addWeighted_1(long src1_nativeObj, double alpha, long src2_nativeObj, double beta, double gamma, long dst_nativeObj);
// C++: void batchDistance(Mat src1, Mat src2, Mat& dist, int dtype, Mat& nidx, int normType = NORM_L2, int K = 0, Mat mask = Mat(), int update = 0, bool crosscheck = false)
private static native void batchDistance_0(long src1_nativeObj, long src2_nativeObj, long dist_nativeObj, int dtype, long nidx_nativeObj, int normType, int K, long mask_nativeObj, int update, boolean crosscheck);
private static native void batchDistance_1(long src1_nativeObj, long src2_nativeObj, long dist_nativeObj, int dtype, long nidx_nativeObj, int normType, int K);
private static native void batchDistance_2(long src1_nativeObj, long src2_nativeObj, long dist_nativeObj, int dtype, long nidx_nativeObj);
// C++: void bitwise_and(Mat src1, Mat src2, Mat& dst, Mat mask = Mat())
private static native void bitwise_and_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, long mask_nativeObj);
private static native void bitwise_and_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj);
// C++: void bitwise_not(Mat src, Mat& dst, Mat mask = Mat())
private static native void bitwise_not_0(long src_nativeObj, long dst_nativeObj, long mask_nativeObj);
private static native void bitwise_not_1(long src_nativeObj, long dst_nativeObj);
// C++: void bitwise_or(Mat src1, Mat src2, Mat& dst, Mat mask = Mat())
private static native void bitwise_or_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, long mask_nativeObj);
private static native void bitwise_or_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj);
// C++: void bitwise_xor(Mat src1, Mat src2, Mat& dst, Mat mask = Mat())
private static native void bitwise_xor_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, long mask_nativeObj);
private static native void bitwise_xor_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj);
// C++: void calcCovarMatrix(Mat samples, Mat& covar, Mat& mean, int flags, int ctype = CV_64F)
private static native void calcCovarMatrix_0(long samples_nativeObj, long covar_nativeObj, long mean_nativeObj, int flags, int ctype);
private static native void calcCovarMatrix_1(long samples_nativeObj, long covar_nativeObj, long mean_nativeObj, int flags);
// C++: void cartToPolar(Mat x, Mat y, Mat& magnitude, Mat& angle, bool angleInDegrees = false)
private static native void cartToPolar_0(long x_nativeObj, long y_nativeObj, long magnitude_nativeObj, long angle_nativeObj, boolean angleInDegrees);
private static native void cartToPolar_1(long x_nativeObj, long y_nativeObj, long magnitude_nativeObj, long angle_nativeObj);
// C++: void compare(Mat src1, Mat src2, Mat& dst, int cmpop)
private static native void compare_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, int cmpop);
// C++: void compare(Mat src1, Scalar src2, Mat& dst, int cmpop)
private static native void compare_1(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, int cmpop);
// C++: void completeSymm(Mat& mtx, bool lowerToUpper = false)
private static native void completeSymm_0(long mtx_nativeObj, boolean lowerToUpper);
private static native void completeSymm_1(long mtx_nativeObj);
// C++: void convertScaleAbs(Mat src, Mat& dst, double alpha = 1, double beta = 0)
private static native void convertScaleAbs_0(long src_nativeObj, long dst_nativeObj, double alpha, double beta);
private static native void convertScaleAbs_1(long src_nativeObj, long dst_nativeObj);
// C++: void copyMakeBorder(Mat src, Mat& dst, int top, int bottom, int left, int right, int borderType, Scalar value = Scalar())
private static native void copyMakeBorder_0(long src_nativeObj, long dst_nativeObj, int top, int bottom, int left, int right, int borderType, double value_val0, double value_val1, double value_val2, double value_val3);
private static native void copyMakeBorder_1(long src_nativeObj, long dst_nativeObj, int top, int bottom, int left, int right, int borderType);
// C++: void dct(Mat src, Mat& dst, int flags = 0)
private static native void dct_0(long src_nativeObj, long dst_nativeObj, int flags);
private static native void dct_1(long src_nativeObj, long dst_nativeObj);
// C++: void dft(Mat src, Mat& dst, int flags = 0, int nonzeroRows = 0)
private static native void dft_0(long src_nativeObj, long dst_nativeObj, int flags, int nonzeroRows);
private static native void dft_1(long src_nativeObj, long dst_nativeObj);
// C++: void divide(Mat src1, Mat src2, Mat& dst, double scale = 1, int dtype = -1)
private static native void divide_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, double scale, int dtype);
private static native void divide_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, double scale);
private static native void divide_2(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj);
// C++: void divide(Mat src1, Scalar src2, Mat& dst, double scale = 1, int dtype = -1)
private static native void divide_3(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, double scale, int dtype);
private static native void divide_4(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, double scale);
private static native void divide_5(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj);
// C++: void divide(double scale, Mat src2, Mat& dst, int dtype = -1)
private static native void divide_6(double scale, long src2_nativeObj, long dst_nativeObj, int dtype);
private static native void divide_7(double scale, long src2_nativeObj, long dst_nativeObj);
// C++: void exp(Mat src, Mat& dst)
private static native void exp_0(long src_nativeObj, long dst_nativeObj);
// C++: void extractChannel(Mat src, Mat& dst, int coi)
private static native void extractChannel_0(long src_nativeObj, long dst_nativeObj, int coi);
// C++: void findNonZero(Mat src, Mat& idx)
private static native void findNonZero_0(long src_nativeObj, long idx_nativeObj);
// C++: void flip(Mat src, Mat& dst, int flipCode)
private static native void flip_0(long src_nativeObj, long dst_nativeObj, int flipCode);
// C++: void gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat& dst, int flags = 0)
private static native void gemm_0(long src1_nativeObj, long src2_nativeObj, double alpha, long src3_nativeObj, double beta, long dst_nativeObj, int flags);
private static native void gemm_1(long src1_nativeObj, long src2_nativeObj, double alpha, long src3_nativeObj, double beta, long dst_nativeObj);
// C++: void hconcat(vector_Mat src, Mat& dst)
private static native void hconcat_0(long src_mat_nativeObj, long dst_nativeObj);
// C++: void idct(Mat src, Mat& dst, int flags = 0)
private static native void idct_0(long src_nativeObj, long dst_nativeObj, int flags);
private static native void idct_1(long src_nativeObj, long dst_nativeObj);
// C++: void idft(Mat src, Mat& dst, int flags = 0, int nonzeroRows = 0)
private static native void idft_0(long src_nativeObj, long dst_nativeObj, int flags, int nonzeroRows);
private static native void idft_1(long src_nativeObj, long dst_nativeObj);
// C++: void inRange(Mat src, Scalar lowerb, Scalar upperb, Mat& dst)
private static native void inRange_0(long src_nativeObj, double lowerb_val0, double lowerb_val1, double lowerb_val2, double lowerb_val3, double upperb_val0, double upperb_val1, double upperb_val2, double upperb_val3, long dst_nativeObj);
// C++: void insertChannel(Mat src, Mat& dst, int coi)
private static native void insertChannel_0(long src_nativeObj, long dst_nativeObj, int coi);
// C++: void log(Mat src, Mat& dst)
private static native void log_0(long src_nativeObj, long dst_nativeObj);
// C++: void magnitude(Mat x, Mat y, Mat& magnitude)
private static native void magnitude_0(long x_nativeObj, long y_nativeObj, long magnitude_nativeObj);
// C++: void max(Mat src1, Mat src2, Mat& dst)
private static native void max_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj);
// C++: void max(Mat src1, Scalar src2, Mat& dst)
private static native void max_1(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj);
// C++: void meanStdDev(Mat src, vector_double& mean, vector_double& stddev, Mat mask = Mat())
private static native void meanStdDev_0(long src_nativeObj, long mean_mat_nativeObj, long stddev_mat_nativeObj, long mask_nativeObj);
private static native void meanStdDev_1(long src_nativeObj, long mean_mat_nativeObj, long stddev_mat_nativeObj);
// C++: void merge(vector_Mat mv, Mat& dst)
private static native void merge_0(long mv_mat_nativeObj, long dst_nativeObj);
// C++: void min(Mat src1, Mat src2, Mat& dst)
private static native void min_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj);
// C++: void min(Mat src1, Scalar src2, Mat& dst)
private static native void min_1(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj);
// C++: void mixChannels(vector_Mat src, vector_Mat dst, vector_int fromTo)
private static native void mixChannels_0(long src_mat_nativeObj, long dst_mat_nativeObj, long fromTo_mat_nativeObj);
// C++: void mulSpectrums(Mat a, Mat b, Mat& c, int flags, bool conjB = false)
private static native void mulSpectrums_0(long a_nativeObj, long b_nativeObj, long c_nativeObj, int flags, boolean conjB);
private static native void mulSpectrums_1(long a_nativeObj, long b_nativeObj, long c_nativeObj, int flags);
// C++: void mulTransposed(Mat src, Mat& dst, bool aTa, Mat delta = Mat(), double scale = 1, int dtype = -1)
private static native void mulTransposed_0(long src_nativeObj, long dst_nativeObj, boolean aTa, long delta_nativeObj, double scale, int dtype);
private static native void mulTransposed_1(long src_nativeObj, long dst_nativeObj, boolean aTa, long delta_nativeObj, double scale);
private static native void mulTransposed_2(long src_nativeObj, long dst_nativeObj, boolean aTa);
// C++: void multiply(Mat src1, Mat src2, Mat& dst, double scale = 1, int dtype = -1)
private static native void multiply_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, double scale, int dtype);
private static native void multiply_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, double scale);
private static native void multiply_2(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj);
// C++: void multiply(Mat src1, Scalar src2, Mat& dst, double scale = 1, int dtype = -1)
private static native void multiply_3(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, double scale, int dtype);
private static native void multiply_4(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, double scale);
private static native void multiply_5(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj);
// C++: void normalize(Mat src, Mat& dst, double alpha = 1, double beta = 0, int norm_type = NORM_L2, int dtype = -1, Mat mask = Mat())
private static native void normalize_0(long src_nativeObj, long dst_nativeObj, double alpha, double beta, int norm_type, int dtype, long mask_nativeObj);
private static native void normalize_1(long src_nativeObj, long dst_nativeObj, double alpha, double beta, int norm_type, int dtype);
private static native void normalize_2(long src_nativeObj, long dst_nativeObj, double alpha, double beta, int norm_type);
private static native void normalize_3(long src_nativeObj, long dst_nativeObj);
// C++: void patchNaNs(Mat& a, double val = 0)
private static native void patchNaNs_0(long a_nativeObj, double val);
private static native void patchNaNs_1(long a_nativeObj);
// C++: void perspectiveTransform(Mat src, Mat& dst, Mat m)
private static native void perspectiveTransform_0(long src_nativeObj, long dst_nativeObj, long m_nativeObj);
// C++: void phase(Mat x, Mat y, Mat& angle, bool angleInDegrees = false)
private static native void phase_0(long x_nativeObj, long y_nativeObj, long angle_nativeObj, boolean angleInDegrees);
private static native void phase_1(long x_nativeObj, long y_nativeObj, long angle_nativeObj);
// C++: void polarToCart(Mat magnitude, Mat angle, Mat& x, Mat& y, bool angleInDegrees = false)
private static native void polarToCart_0(long magnitude_nativeObj, long angle_nativeObj, long x_nativeObj, long y_nativeObj, boolean angleInDegrees);
private static native void polarToCart_1(long magnitude_nativeObj, long angle_nativeObj, long x_nativeObj, long y_nativeObj);
// C++: void pow(Mat src, double power, Mat& dst)
private static native void pow_0(long src_nativeObj, double power, long dst_nativeObj);
// C++: void randShuffle(Mat& dst, double iterFactor = 1., RNG* rng = 0)
private static native void randShuffle_0(long dst_nativeObj, double iterFactor);
private static native void randShuffle_1(long dst_nativeObj);
// C++: void randn(Mat& dst, double mean, double stddev)
private static native void randn_0(long dst_nativeObj, double mean, double stddev);
// C++: void randu(Mat& dst, double low, double high)
private static native void randu_0(long dst_nativeObj, double low, double high);
// C++: void reduce(Mat src, Mat& dst, int dim, int rtype, int dtype = -1)
private static native void reduce_0(long src_nativeObj, long dst_nativeObj, int dim, int rtype, int dtype);
private static native void reduce_1(long src_nativeObj, long dst_nativeObj, int dim, int rtype);
// C++: void repeat(Mat src, int ny, int nx, Mat& dst)
private static native void repeat_0(long src_nativeObj, int ny, int nx, long dst_nativeObj);
// C++: void scaleAdd(Mat src1, double alpha, Mat src2, Mat& dst)
private static native void scaleAdd_0(long src1_nativeObj, double alpha, long src2_nativeObj, long dst_nativeObj);
// C++: void setErrorVerbosity(bool verbose)
private static native void setErrorVerbosity_0(boolean verbose);
// C++: void setIdentity(Mat& mtx, Scalar s = Scalar(1))
private static native void setIdentity_0(long mtx_nativeObj, double s_val0, double s_val1, double s_val2, double s_val3);
private static native void setIdentity_1(long mtx_nativeObj);
// C++: void setNumThreads(int nthreads)
private static native void setNumThreads_0(int nthreads);
// C++: void sort(Mat src, Mat& dst, int flags)
private static native void sort_0(long src_nativeObj, long dst_nativeObj, int flags);
// C++: void sortIdx(Mat src, Mat& dst, int flags)
private static native void sortIdx_0(long src_nativeObj, long dst_nativeObj, int flags);
// C++: void split(Mat m, vector_Mat& mv)
private static native void split_0(long m_nativeObj, long mv_mat_nativeObj);
// C++: void sqrt(Mat src, Mat& dst)
private static native void sqrt_0(long src_nativeObj, long dst_nativeObj);
// C++: void subtract(Mat src1, Mat src2, Mat& dst, Mat mask = Mat(), int dtype = -1)
private static native void subtract_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, long mask_nativeObj, int dtype);
private static native void subtract_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, long mask_nativeObj);
private static native void subtract_2(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj);
// C++: void subtract(Mat src1, Scalar src2, Mat& dst, Mat mask = Mat(), int dtype = -1)
private static native void subtract_3(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, long mask_nativeObj, int dtype);
private static native void subtract_4(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, long mask_nativeObj);
private static native void subtract_5(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj);
// C++: void transform(Mat src, Mat& dst, Mat m)
private static native void transform_0(long src_nativeObj, long dst_nativeObj, long m_nativeObj);
// C++: void transpose(Mat src, Mat& dst)
private static native void transpose_0(long src_nativeObj, long dst_nativeObj);
// C++: void vconcat(vector_Mat src, Mat& dst)
private static native void vconcat_0(long src_mat_nativeObj, long dst_nativeObj);
private static native double[] n_minMaxLocManual(long src_nativeObj, long mask_nativeObj);
}
| 79,854 | 30.01165 | 241 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/MatOfPoint3.java | package org.opencv.core;
import java.util.Arrays;
import java.util.List;
public class MatOfPoint3 extends Mat {
// 32SC3
private static final int _depth = CvType.CV_32S;
private static final int _channels = 3;
public MatOfPoint3() {
super();
}
protected MatOfPoint3(long addr) {
super(addr);
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public static MatOfPoint3 fromNativeAddr(long addr) {
return new MatOfPoint3(addr);
}
public MatOfPoint3(Mat m) {
super(m, Range.all());
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public MatOfPoint3(Point3...a) {
super();
fromArray(a);
}
public void alloc(int elemNumber) {
if(elemNumber>0)
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
}
public void fromArray(Point3...a) {
if(a==null || a.length==0)
return;
int num = a.length;
alloc(num);
int buff[] = new int[num * _channels];
for(int i=0; i<num; i++) {
Point3 p = a[i];
buff[_channels*i+0] = (int) p.x;
buff[_channels*i+1] = (int) p.y;
buff[_channels*i+2] = (int) p.z;
}
put(0, 0, buff); //TODO: check ret val!
}
public Point3[] toArray() {
int num = (int) total();
Point3[] ap = new Point3[num];
if(num == 0)
return ap;
int buff[] = new int[num * _channels];
get(0, 0, buff); //TODO: check ret val!
for(int i=0; i<num; i++)
ap[i] = new Point3(buff[i*_channels], buff[i*_channels+1], buff[i*_channels+2]);
return ap;
}
public void fromList(List<Point3> lp) {
Point3 ap[] = lp.toArray(new Point3[0]);
fromArray(ap);
}
public List<Point3> toList() {
Point3[] ap = toArray();
return Arrays.asList(ap);
}
}
| 2,176 | 26.2125 | 92 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/MatOfInt4.java | package org.opencv.core;
import java.util.Arrays;
import java.util.List;
public class MatOfInt4 extends Mat {
// 32SC4
private static final int _depth = CvType.CV_32S;
private static final int _channels = 4;
public MatOfInt4() {
super();
}
protected MatOfInt4(long addr) {
super(addr);
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public static MatOfInt4 fromNativeAddr(long addr) {
return new MatOfInt4(addr);
}
public MatOfInt4(Mat m) {
super(m, Range.all());
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public MatOfInt4(int...a) {
super();
fromArray(a);
}
public void alloc(int elemNumber) {
if(elemNumber>0)
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
}
public void fromArray(int...a) {
if(a==null || a.length==0)
return;
int num = a.length / _channels;
alloc(num);
put(0, 0, a); //TODO: check ret val!
}
public int[] toArray() {
int num = checkVector(_channels, _depth);
if(num < 0)
throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
int[] a = new int[num * _channels];
if(num == 0)
return a;
get(0, 0, a); //TODO: check ret val!
return a;
}
public void fromList(List<Integer> lb) {
if(lb==null || lb.size()==0)
return;
Integer ab[] = lb.toArray(new Integer[0]);
int a[] = new int[ab.length];
for(int i=0; i<ab.length; i++)
a[i] = ab[i];
fromArray(a);
}
public List<Integer> toList() {
int[] a = toArray();
Integer ab[] = new Integer[a.length];
for(int i=0; i<a.length; i++)
ab[i] = a[i];
return Arrays.asList(ab);
}
}
| 2,137 | 25.395062 | 96 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/Scalar.java | package org.opencv.core;
//javadoc:Scalar_
public class Scalar {
public double val[];
public Scalar(double v0, double v1, double v2, double v3) {
val = new double[] { v0, v1, v2, v3 };
}
public Scalar(double v0, double v1, double v2) {
val = new double[] { v0, v1, v2, 0 };
}
public Scalar(double v0, double v1) {
val = new double[] { v0, v1, 0, 0 };
}
public Scalar(double v0) {
val = new double[] { v0, 0, 0, 0 };
}
public Scalar(double[] vals) {
if (vals != null && vals.length == 4)
val = vals.clone();
else {
val = new double[4];
set(vals);
}
}
public void set(double[] vals) {
if (vals != null) {
val[0] = vals.length > 0 ? vals[0] : 0;
val[1] = vals.length > 1 ? vals[1] : 0;
val[2] = vals.length > 2 ? vals[2] : 0;
val[3] = vals.length > 3 ? vals[3] : 0;
} else
val[0] = val[1] = val[2] = val[3] = 0;
}
public static Scalar all(double v) {
return new Scalar(v, v, v, v);
}
public Scalar clone() {
return new Scalar(val);
}
public Scalar mul(Scalar it, double scale) {
return new Scalar(val[0] * it.val[0] * scale, val[1] * it.val[1] * scale,
val[2] * it.val[2] * scale, val[3] * it.val[3] * scale);
}
public Scalar mul(Scalar it) {
return mul(it, 1);
}
public Scalar conj() {
return new Scalar(val[0], -val[1], -val[2], -val[3]);
}
public boolean isReal() {
return val[1] == 0 && val[2] == 0 && val[3] == 0;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + java.util.Arrays.hashCode(val);
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (!(obj instanceof Scalar)) return false;
Scalar it = (Scalar) obj;
if (!java.util.Arrays.equals(val, it.val)) return false;
return true;
}
@Override
public String toString() {
return "[" + val[0] + ", " + val[1] + ", " + val[2] + ", " + val[3] + "]";
}
}
| 2,265 | 23.901099 | 82 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/Point3.java | package org.opencv.core;
//javadoc:Point3_
public class Point3 {
public double x, y, z;
public Point3(double x, double y, double z) {
this.x = x;
this.y = y;
this.z = z;
}
public Point3() {
this(0, 0, 0);
}
public Point3(Point p) {
x = p.x;
y = p.y;
z = 0;
}
public Point3(double[] vals) {
this();
set(vals);
}
public void set(double[] vals) {
if (vals != null) {
x = vals.length > 0 ? vals[0] : 0;
y = vals.length > 1 ? vals[1] : 0;
z = vals.length > 2 ? vals[2] : 0;
} else {
x = 0;
y = 0;
z = 0;
}
}
public Point3 clone() {
return new Point3(x, y, z);
}
public double dot(Point3 p) {
return x * p.x + y * p.y + z * p.z;
}
public Point3 cross(Point3 p) {
return new Point3(y * p.z - z * p.y, z * p.x - x * p.z, x * p.y - y * p.x);
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
long temp;
temp = Double.doubleToLongBits(x);
result = prime * result + (int) (temp ^ (temp >>> 32));
temp = Double.doubleToLongBits(y);
result = prime * result + (int) (temp ^ (temp >>> 32));
temp = Double.doubleToLongBits(z);
result = prime * result + (int) (temp ^ (temp >>> 32));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (!(obj instanceof Point3)) return false;
Point3 it = (Point3) obj;
return x == it.x && y == it.y && z == it.z;
}
@Override
public String toString() {
return "{" + x + ", " + y + ", " + z + "}";
}
}
| 1,814 | 21.6875 | 83 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/Rect.java | package org.opencv.core;
//javadoc:Rect_
public class Rect {
public int x, y, width, height;
public Rect(int x, int y, int width, int height) {
this.x = x;
this.y = y;
this.width = width;
this.height = height;
}
public Rect() {
this(0, 0, 0, 0);
}
public Rect(Point p1, Point p2) {
x = (int) (p1.x < p2.x ? p1.x : p2.x);
y = (int) (p1.y < p2.y ? p1.y : p2.y);
width = (int) (p1.x > p2.x ? p1.x : p2.x) - x;
height = (int) (p1.y > p2.y ? p1.y : p2.y) - y;
}
public Rect(Point p, Size s) {
this((int) p.x, (int) p.y, (int) s.width, (int) s.height);
}
public Rect(double[] vals) {
set(vals);
}
public void set(double[] vals) {
if (vals != null) {
x = vals.length > 0 ? (int) vals[0] : 0;
y = vals.length > 1 ? (int) vals[1] : 0;
width = vals.length > 2 ? (int) vals[2] : 0;
height = vals.length > 3 ? (int) vals[3] : 0;
} else {
x = 0;
y = 0;
width = 0;
height = 0;
}
}
public Rect clone() {
return new Rect(x, y, width, height);
}
public Point tl() {
return new Point(x, y);
}
public Point br() {
return new Point(x + width, y + height);
}
public Size size() {
return new Size(width, height);
}
public double area() {
return width * height;
}
public boolean contains(Point p) {
return x <= p.x && p.x < x + width && y <= p.y && p.y < y + height;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
long temp;
temp = Double.doubleToLongBits(height);
result = prime * result + (int) (temp ^ (temp >>> 32));
temp = Double.doubleToLongBits(width);
result = prime * result + (int) (temp ^ (temp >>> 32));
temp = Double.doubleToLongBits(x);
result = prime * result + (int) (temp ^ (temp >>> 32));
temp = Double.doubleToLongBits(y);
result = prime * result + (int) (temp ^ (temp >>> 32));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (!(obj instanceof Rect)) return false;
Rect it = (Rect) obj;
return x == it.x && y == it.y && width == it.width && height == it.height;
}
@Override
public String toString() {
return "{" + x + ", " + y + ", " + width + "x" + height + "}";
}
}
| 2,585 | 24.60396 | 82 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/MatOfDouble.java | package org.opencv.core;
import java.util.Arrays;
import java.util.List;
public class MatOfDouble extends Mat {
// 64FC(x)
private static final int _depth = CvType.CV_64F;
private static final int _channels = 1;
public MatOfDouble() {
super();
}
protected MatOfDouble(long addr) {
super(addr);
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public static MatOfDouble fromNativeAddr(long addr) {
return new MatOfDouble(addr);
}
public MatOfDouble(Mat m) {
super(m, Range.all());
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public MatOfDouble(double...a) {
super();
fromArray(a);
}
public void alloc(int elemNumber) {
if(elemNumber>0)
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
}
public void fromArray(double...a) {
if(a==null || a.length==0)
return;
int num = a.length / _channels;
alloc(num);
put(0, 0, a); //TODO: check ret val!
}
public double[] toArray() {
int num = checkVector(_channels, _depth);
if(num < 0)
throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
double[] a = new double[num * _channels];
if(num == 0)
return a;
get(0, 0, a); //TODO: check ret val!
return a;
}
public void fromList(List<Double> lb) {
if(lb==null || lb.size()==0)
return;
Double ab[] = lb.toArray(new Double[0]);
double a[] = new double[ab.length];
for(int i=0; i<ab.length; i++)
a[i] = ab[i];
fromArray(a);
}
public List<Double> toList() {
double[] a = toArray();
Double ab[] = new Double[a.length];
for(int i=0; i<a.length; i++)
ab[i] = a[i];
return Arrays.asList(ab);
}
}
| 2,170 | 26.1375 | 96 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/MatOfPoint2f.java | package org.opencv.core;
import java.util.Arrays;
import java.util.List;
public class MatOfPoint2f extends Mat {
// 32FC2
private static final int _depth = CvType.CV_32F;
private static final int _channels = 2;
public MatOfPoint2f() {
super();
}
protected MatOfPoint2f(long addr) {
super(addr);
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public static MatOfPoint2f fromNativeAddr(long addr) {
return new MatOfPoint2f(addr);
}
public MatOfPoint2f(Mat m) {
super(m, Range.all());
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public MatOfPoint2f(Point...a) {
super();
fromArray(a);
}
public void alloc(int elemNumber) {
if(elemNumber>0)
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
}
public void fromArray(Point...a) {
if(a==null || a.length==0)
return;
int num = a.length;
alloc(num);
float buff[] = new float[num * _channels];
for(int i=0; i<num; i++) {
Point p = a[i];
buff[_channels*i+0] = (float) p.x;
buff[_channels*i+1] = (float) p.y;
}
put(0, 0, buff); //TODO: check ret val!
}
public Point[] toArray() {
int num = (int) total();
Point[] ap = new Point[num];
if(num == 0)
return ap;
float buff[] = new float[num * _channels];
get(0, 0, buff); //TODO: check ret val!
for(int i=0; i<num; i++)
ap[i] = new Point(buff[i*_channels], buff[i*_channels+1]);
return ap;
}
public void fromList(List<Point> lp) {
Point ap[] = lp.toArray(new Point[0]);
fromArray(ap);
}
public List<Point> toList() {
Point[] ap = toArray();
return Arrays.asList(ap);
}
}
| 2,117 | 25.810127 | 76 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/MatOfPoint3f.java | package org.opencv.core;
import java.util.Arrays;
import java.util.List;
public class MatOfPoint3f extends Mat {
// 32FC3
private static final int _depth = CvType.CV_32F;
private static final int _channels = 3;
public MatOfPoint3f() {
super();
}
protected MatOfPoint3f(long addr) {
super(addr);
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public static MatOfPoint3f fromNativeAddr(long addr) {
return new MatOfPoint3f(addr);
}
public MatOfPoint3f(Mat m) {
super(m, Range.all());
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public MatOfPoint3f(Point3...a) {
super();
fromArray(a);
}
public void alloc(int elemNumber) {
if(elemNumber>0)
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
}
public void fromArray(Point3...a) {
if(a==null || a.length==0)
return;
int num = a.length;
alloc(num);
float buff[] = new float[num * _channels];
for(int i=0; i<num; i++) {
Point3 p = a[i];
buff[_channels*i+0] = (float) p.x;
buff[_channels*i+1] = (float) p.y;
buff[_channels*i+2] = (float) p.z;
}
put(0, 0, buff); //TODO: check ret val!
}
public Point3[] toArray() {
int num = (int) total();
Point3[] ap = new Point3[num];
if(num == 0)
return ap;
float buff[] = new float[num * _channels];
get(0, 0, buff); //TODO: check ret val!
for(int i=0; i<num; i++)
ap[i] = new Point3(buff[i*_channels], buff[i*_channels+1], buff[i*_channels+2]);
return ap;
}
public void fromList(List<Point3> lp) {
Point3 ap[] = lp.toArray(new Point3[0]);
fromArray(ap);
}
public List<Point3> toList() {
Point3[] ap = toArray();
return Arrays.asList(ap);
}
}
| 2,197 | 26.475 | 92 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/RotatedRect.java | package org.opencv.core;
//javadoc:RotatedRect_
public class RotatedRect {
public Point center;
public Size size;
public double angle;
public RotatedRect() {
this.center = new Point();
this.size = new Size();
this.angle = 0;
}
public RotatedRect(Point c, Size s, double a) {
this.center = c.clone();
this.size = s.clone();
this.angle = a;
}
public RotatedRect(double[] vals) {
this();
set(vals);
}
public void set(double[] vals) {
if (vals != null) {
center.x = vals.length > 0 ? (double) vals[0] : 0;
center.y = vals.length > 1 ? (double) vals[1] : 0;
size.width = vals.length > 2 ? (double) vals[2] : 0;
size.height = vals.length > 3 ? (double) vals[3] : 0;
angle = vals.length > 4 ? (double) vals[4] : 0;
} else {
center.x = 0;
center.x = 0;
size.width = 0;
size.height = 0;
angle = 0;
}
}
public void points(Point pt[])
{
double _angle = angle * Math.PI / 180.0;
double b = (double) Math.cos(_angle) * 0.5f;
double a = (double) Math.sin(_angle) * 0.5f;
pt[0] = new Point(
center.x - a * size.height - b * size.width,
center.y + b * size.height - a * size.width);
pt[1] = new Point(
center.x + a * size.height - b * size.width,
center.y - b * size.height - a * size.width);
pt[2] = new Point(
2 * center.x - pt[0].x,
2 * center.y - pt[0].y);
pt[3] = new Point(
2 * center.x - pt[1].x,
2 * center.y - pt[1].y);
}
public Rect boundingRect()
{
Point pt[] = new Point[4];
points(pt);
Rect r = new Rect((int) Math.floor(Math.min(Math.min(Math.min(pt[0].x, pt[1].x), pt[2].x), pt[3].x)),
(int) Math.floor(Math.min(Math.min(Math.min(pt[0].y, pt[1].y), pt[2].y), pt[3].y)),
(int) Math.ceil(Math.max(Math.max(Math.max(pt[0].x, pt[1].x), pt[2].x), pt[3].x)),
(int) Math.ceil(Math.max(Math.max(Math.max(pt[0].y, pt[1].y), pt[2].y), pt[3].y)));
r.width -= r.x - 1;
r.height -= r.y - 1;
return r;
}
public RotatedRect clone() {
return new RotatedRect(center, size, angle);
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
long temp;
temp = Double.doubleToLongBits(center.x);
result = prime * result + (int) (temp ^ (temp >>> 32));
temp = Double.doubleToLongBits(center.y);
result = prime * result + (int) (temp ^ (temp >>> 32));
temp = Double.doubleToLongBits(size.width);
result = prime * result + (int) (temp ^ (temp >>> 32));
temp = Double.doubleToLongBits(size.height);
result = prime * result + (int) (temp ^ (temp >>> 32));
temp = Double.doubleToLongBits(angle);
result = prime * result + (int) (temp ^ (temp >>> 32));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (!(obj instanceof RotatedRect)) return false;
RotatedRect it = (RotatedRect) obj;
return center.equals(it.center) && size.equals(it.size) && angle == it.angle;
}
@Override
public String toString() {
return "{ " + center + " " + size + " * " + angle + " }";
}
}
| 3,573 | 30.350877 | 109 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/MatOfDMatch.java | package org.opencv.core;
import java.util.Arrays;
import java.util.List;
import org.opencv.core.DMatch;
public class MatOfDMatch extends Mat {
// 32FC4
private static final int _depth = CvType.CV_32F;
private static final int _channels = 4;
public MatOfDMatch() {
super();
}
protected MatOfDMatch(long addr) {
super(addr);
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat: " + toString());
//FIXME: do we need release() here?
}
public static MatOfDMatch fromNativeAddr(long addr) {
return new MatOfDMatch(addr);
}
public MatOfDMatch(Mat m) {
super(m, Range.all());
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat: " + toString());
//FIXME: do we need release() here?
}
public MatOfDMatch(DMatch...ap) {
super();
fromArray(ap);
}
public void alloc(int elemNumber) {
if(elemNumber>0)
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
}
public void fromArray(DMatch...a) {
if(a==null || a.length==0)
return;
int num = a.length;
alloc(num);
float buff[] = new float[num * _channels];
for(int i=0; i<num; i++) {
DMatch m = a[i];
buff[_channels*i+0] = m.queryIdx;
buff[_channels*i+1] = m.trainIdx;
buff[_channels*i+2] = m.imgIdx;
buff[_channels*i+3] = m.distance;
}
put(0, 0, buff); //TODO: check ret val!
}
public DMatch[] toArray() {
int num = (int) total();
DMatch[] a = new DMatch[num];
if(num == 0)
return a;
float buff[] = new float[num * _channels];
get(0, 0, buff); //TODO: check ret val!
for(int i=0; i<num; i++)
a[i] = new DMatch((int) buff[_channels*i+0], (int) buff[_channels*i+1], (int) buff[_channels*i+2], buff[_channels*i+3]);
return a;
}
public void fromList(List<DMatch> ldm) {
DMatch adm[] = ldm.toArray(new DMatch[0]);
fromArray(adm);
}
public List<DMatch> toList() {
DMatch[] adm = toArray();
return Arrays.asList(adm);
}
}
| 2,339 | 26.857143 | 132 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/CvType.java | package org.opencv.core;
public final class CvType {
// type depth constants
public static final int
CV_8U = 0, CV_8S = 1,
CV_16U = 2, CV_16S = 3,
CV_32S = 4,
CV_32F = 5,
CV_64F = 6,
CV_USRTYPE1 = 7;
// predefined type constants
public static final int
CV_8UC1 = CV_8UC(1), CV_8UC2 = CV_8UC(2), CV_8UC3 = CV_8UC(3), CV_8UC4 = CV_8UC(4),
CV_8SC1 = CV_8SC(1), CV_8SC2 = CV_8SC(2), CV_8SC3 = CV_8SC(3), CV_8SC4 = CV_8SC(4),
CV_16UC1 = CV_16UC(1), CV_16UC2 = CV_16UC(2), CV_16UC3 = CV_16UC(3), CV_16UC4 = CV_16UC(4),
CV_16SC1 = CV_16SC(1), CV_16SC2 = CV_16SC(2), CV_16SC3 = CV_16SC(3), CV_16SC4 = CV_16SC(4),
CV_32SC1 = CV_32SC(1), CV_32SC2 = CV_32SC(2), CV_32SC3 = CV_32SC(3), CV_32SC4 = CV_32SC(4),
CV_32FC1 = CV_32FC(1), CV_32FC2 = CV_32FC(2), CV_32FC3 = CV_32FC(3), CV_32FC4 = CV_32FC(4),
CV_64FC1 = CV_64FC(1), CV_64FC2 = CV_64FC(2), CV_64FC3 = CV_64FC(3), CV_64FC4 = CV_64FC(4);
private static final int CV_CN_MAX = 512, CV_CN_SHIFT = 3, CV_DEPTH_MAX = (1 << CV_CN_SHIFT);
public static final int makeType(int depth, int channels) {
if (channels <= 0 || channels >= CV_CN_MAX) {
throw new java.lang.UnsupportedOperationException(
"Channels count should be 1.." + (CV_CN_MAX - 1));
}
if (depth < 0 || depth >= CV_DEPTH_MAX) {
throw new java.lang.UnsupportedOperationException(
"Data type depth should be 0.." + (CV_DEPTH_MAX - 1));
}
return (depth & (CV_DEPTH_MAX - 1)) + ((channels - 1) << CV_CN_SHIFT);
}
public static final int CV_8UC(int ch) {
return makeType(CV_8U, ch);
}
public static final int CV_8SC(int ch) {
return makeType(CV_8S, ch);
}
public static final int CV_16UC(int ch) {
return makeType(CV_16U, ch);
}
public static final int CV_16SC(int ch) {
return makeType(CV_16S, ch);
}
public static final int CV_32SC(int ch) {
return makeType(CV_32S, ch);
}
public static final int CV_32FC(int ch) {
return makeType(CV_32F, ch);
}
public static final int CV_64FC(int ch) {
return makeType(CV_64F, ch);
}
public static final int channels(int type) {
return (type >> CV_CN_SHIFT) + 1;
}
public static final int depth(int type) {
return type & (CV_DEPTH_MAX - 1);
}
public static final boolean isInteger(int type) {
return depth(type) < CV_32F;
}
public static final int ELEM_SIZE(int type) {
switch (depth(type)) {
case CV_8U:
case CV_8S:
return channels(type);
case CV_16U:
case CV_16S:
return 2 * channels(type);
case CV_32S:
case CV_32F:
return 4 * channels(type);
case CV_64F:
return 8 * channels(type);
default:
throw new java.lang.UnsupportedOperationException(
"Unsupported CvType value: " + type);
}
}
public static final String typeToString(int type) {
String s;
switch (depth(type)) {
case CV_8U:
s = "CV_8U";
break;
case CV_8S:
s = "CV_8S";
break;
case CV_16U:
s = "CV_16U";
break;
case CV_16S:
s = "CV_16S";
break;
case CV_32S:
s = "CV_32S";
break;
case CV_32F:
s = "CV_32F";
break;
case CV_64F:
s = "CV_64F";
break;
case CV_USRTYPE1:
s = "CV_USRTYPE1";
break;
default:
throw new java.lang.UnsupportedOperationException(
"Unsupported CvType value: " + type);
}
int ch = channels(type);
if (ch <= 4)
return s + "C" + ch;
else
return s + "C(" + ch + ")";
}
}
| 4,089 | 28.854015 | 103 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/MatOfFloat.java | package org.opencv.core;
import java.util.Arrays;
import java.util.List;
public class MatOfFloat extends Mat {
// 32FC1
private static final int _depth = CvType.CV_32F;
private static final int _channels = 1;
public MatOfFloat() {
super();
}
protected MatOfFloat(long addr) {
super(addr);
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public static MatOfFloat fromNativeAddr(long addr) {
return new MatOfFloat(addr);
}
public MatOfFloat(Mat m) {
super(m, Range.all());
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public MatOfFloat(float...a) {
super();
fromArray(a);
}
public void alloc(int elemNumber) {
if(elemNumber>0)
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
}
public void fromArray(float...a) {
if(a==null || a.length==0)
return;
int num = a.length / _channels;
alloc(num);
put(0, 0, a); //TODO: check ret val!
}
public float[] toArray() {
int num = checkVector(_channels, _depth);
if(num < 0)
throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
float[] a = new float[num * _channels];
if(num == 0)
return a;
get(0, 0, a); //TODO: check ret val!
return a;
}
public void fromList(List<Float> lb) {
if(lb==null || lb.size()==0)
return;
Float ab[] = lb.toArray(new Float[0]);
float a[] = new float[ab.length];
for(int i=0; i<ab.length; i++)
a[i] = ab[i];
fromArray(a);
}
public List<Float> toList() {
float[] a = toArray();
Float ab[] = new Float[a.length];
for(int i=0; i<a.length; i++)
ab[i] = a[i];
return Arrays.asList(ab);
}
}
| 2,147 | 25.85 | 96 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/MatOfFloat6.java | package org.opencv.core;
import java.util.Arrays;
import java.util.List;
public class MatOfFloat6 extends Mat {
// 32FC6
private static final int _depth = CvType.CV_32F;
private static final int _channels = 6;
public MatOfFloat6() {
super();
}
protected MatOfFloat6(long addr) {
super(addr);
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public static MatOfFloat6 fromNativeAddr(long addr) {
return new MatOfFloat6(addr);
}
public MatOfFloat6(Mat m) {
super(m, Range.all());
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public MatOfFloat6(float...a) {
super();
fromArray(a);
}
public void alloc(int elemNumber) {
if(elemNumber>0)
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
}
public void fromArray(float...a) {
if(a==null || a.length==0)
return;
int num = a.length / _channels;
alloc(num);
put(0, 0, a); //TODO: check ret val!
}
public float[] toArray() {
int num = checkVector(_channels, _depth);
if(num < 0)
throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
float[] a = new float[num * _channels];
if(num == 0)
return a;
get(0, 0, a); //TODO: check ret val!
return a;
}
public void fromList(List<Float> lb) {
if(lb==null || lb.size()==0)
return;
Float ab[] = lb.toArray(new Float[0]);
float a[] = new float[ab.length];
for(int i=0; i<ab.length; i++)
a[i] = ab[i];
fromArray(a);
}
public List<Float> toList() {
float[] a = toArray();
Float ab[] = new Float[a.length];
for(int i=0; i<a.length; i++)
ab[i] = a[i];
return Arrays.asList(ab);
}
}
| 2,154 | 25.9375 | 96 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/Point.java | package org.opencv.core;
//javadoc:Point_
public class Point {
public double x, y;
public Point(double x, double y) {
this.x = x;
this.y = y;
}
public Point() {
this(0, 0);
}
public Point(double[] vals) {
this();
set(vals);
}
public void set(double[] vals) {
if (vals != null) {
x = vals.length > 0 ? vals[0] : 0;
y = vals.length > 1 ? vals[1] : 0;
} else {
x = 0;
y = 0;
}
}
public Point clone() {
return new Point(x, y);
}
public double dot(Point p) {
return x * p.x + y * p.y;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
long temp;
temp = Double.doubleToLongBits(x);
result = prime * result + (int) (temp ^ (temp >>> 32));
temp = Double.doubleToLongBits(y);
result = prime * result + (int) (temp ^ (temp >>> 32));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (!(obj instanceof Point)) return false;
Point it = (Point) obj;
return x == it.x && y == it.y;
}
public boolean inside(Rect r) {
return r.contains(this);
}
@Override
public String toString() {
return "{" + x + ", " + y + "}";
}
}
| 1,421 | 19.608696 | 63 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/KeyPoint.java | package org.opencv.core;
import org.opencv.core.Point;
//javadoc: KeyPoint
public class KeyPoint {
/**
* Coordinates of the keypoint.
*/
public Point pt;
/**
* Diameter of the useful keypoint adjacent area.
*/
public float size;
/**
* Computed orientation of the keypoint (-1 if not applicable).
*/
public float angle;
/**
* The response, by which the strongest keypoints have been selected. Can
* be used for further sorting or subsampling.
*/
public float response;
/**
* Octave (pyramid layer), from which the keypoint has been extracted.
*/
public int octave;
/**
* Object ID, that can be used to cluster keypoints by an object they
* belong to.
*/
public int class_id;
// javadoc:KeyPoint::KeyPoint(x,y,_size,_angle,_response,_octave,_class_id)
public KeyPoint(float x, float y, float _size, float _angle, float _response, int _octave, int _class_id)
{
pt = new Point(x, y);
size = _size;
angle = _angle;
response = _response;
octave = _octave;
class_id = _class_id;
}
// javadoc: KeyPoint::KeyPoint()
public KeyPoint()
{
this(0, 0, 0, -1, 0, 0, -1);
}
// javadoc: KeyPoint::KeyPoint(x, y, _size, _angle, _response, _octave)
public KeyPoint(float x, float y, float _size, float _angle, float _response, int _octave)
{
this(x, y, _size, _angle, _response, _octave, -1);
}
// javadoc: KeyPoint::KeyPoint(x, y, _size, _angle, _response)
public KeyPoint(float x, float y, float _size, float _angle, float _response)
{
this(x, y, _size, _angle, _response, 0, -1);
}
// javadoc: KeyPoint::KeyPoint(x, y, _size, _angle)
public KeyPoint(float x, float y, float _size, float _angle)
{
this(x, y, _size, _angle, 0, 0, -1);
}
// javadoc: KeyPoint::KeyPoint(x, y, _size)
public KeyPoint(float x, float y, float _size)
{
this(x, y, _size, -1, 0, 0, -1);
}
@Override
public String toString() {
return "KeyPoint [pt=" + pt + ", size=" + size + ", angle=" + angle
+ ", response=" + response + ", octave=" + octave
+ ", class_id=" + class_id + "]";
}
}
| 2,306 | 26.464286 | 109 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/Size.java | package org.opencv.core;
//javadoc:Size_
public class Size {
public double width, height;
public Size(double width, double height) {
this.width = width;
this.height = height;
}
public Size() {
this(0, 0);
}
public Size(Point p) {
width = p.x;
height = p.y;
}
public Size(double[] vals) {
set(vals);
}
public void set(double[] vals) {
if (vals != null) {
width = vals.length > 0 ? vals[0] : 0;
height = vals.length > 1 ? vals[1] : 0;
} else {
width = 0;
height = 0;
}
}
public double area() {
return width * height;
}
public Size clone() {
return new Size(width, height);
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
long temp;
temp = Double.doubleToLongBits(height);
result = prime * result + (int) (temp ^ (temp >>> 32));
temp = Double.doubleToLongBits(width);
result = prime * result + (int) (temp ^ (temp >>> 32));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (!(obj instanceof Size)) return false;
Size it = (Size) obj;
return width == it.width && height == it.height;
}
@Override
public String toString() {
return (int)width + "x" + (int)height;
}
}
| 1,484 | 20.214286 | 63 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/MatOfPoint.java | package org.opencv.core;
import java.util.Arrays;
import java.util.List;
public class MatOfPoint extends Mat {
// 32SC2
private static final int _depth = CvType.CV_32S;
private static final int _channels = 2;
public MatOfPoint() {
super();
}
protected MatOfPoint(long addr) {
super(addr);
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public static MatOfPoint fromNativeAddr(long addr) {
return new MatOfPoint(addr);
}
public MatOfPoint(Mat m) {
super(m, Range.all());
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public MatOfPoint(Point...a) {
super();
fromArray(a);
}
public void alloc(int elemNumber) {
if(elemNumber>0)
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
}
public void fromArray(Point...a) {
if(a==null || a.length==0)
return;
int num = a.length;
alloc(num);
int buff[] = new int[num * _channels];
for(int i=0; i<num; i++) {
Point p = a[i];
buff[_channels*i+0] = (int) p.x;
buff[_channels*i+1] = (int) p.y;
}
put(0, 0, buff); //TODO: check ret val!
}
public Point[] toArray() {
int num = (int) total();
Point[] ap = new Point[num];
if(num == 0)
return ap;
int buff[] = new int[num * _channels];
get(0, 0, buff); //TODO: check ret val!
for(int i=0; i<num; i++)
ap[i] = new Point(buff[i*_channels], buff[i*_channels+1]);
return ap;
}
public void fromList(List<Point> lp) {
Point ap[] = lp.toArray(new Point[0]);
fromArray(ap);
}
public List<Point> toList() {
Point[] ap = toArray();
return Arrays.asList(ap);
}
}
| 2,091 | 25.481013 | 76 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/MatOfByte.java | package org.opencv.core;
import java.util.Arrays;
import java.util.List;
public class MatOfByte extends Mat {
// 8UC(x)
private static final int _depth = CvType.CV_8U;
private static final int _channels = 1;
public MatOfByte() {
super();
}
protected MatOfByte(long addr) {
super(addr);
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public static MatOfByte fromNativeAddr(long addr) {
return new MatOfByte(addr);
}
public MatOfByte(Mat m) {
super(m, Range.all());
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public MatOfByte(byte...a) {
super();
fromArray(a);
}
public void alloc(int elemNumber) {
if(elemNumber>0)
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
}
public void fromArray(byte...a) {
if(a==null || a.length==0)
return;
int num = a.length / _channels;
alloc(num);
put(0, 0, a); //TODO: check ret val!
}
public byte[] toArray() {
int num = checkVector(_channels, _depth);
if(num < 0)
throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
byte[] a = new byte[num * _channels];
if(num == 0)
return a;
get(0, 0, a); //TODO: check ret val!
return a;
}
public void fromList(List<Byte> lb) {
if(lb==null || lb.size()==0)
return;
Byte ab[] = lb.toArray(new Byte[0]);
byte a[] = new byte[ab.length];
for(int i=0; i<ab.length; i++)
a[i] = ab[i];
fromArray(a);
}
public List<Byte> toList() {
byte[] a = toArray();
Byte ab[] = new Byte[a.length];
for(int i=0; i<a.length; i++)
ab[i] = a[i];
return Arrays.asList(ab);
}
}
| 2,126 | 25.5875 | 96 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/core/TermCriteria.java | package org.opencv.core;
//javadoc:TermCriteria
public class TermCriteria {
/**
* The maximum number of iterations or elements to compute
*/
public static final int COUNT = 1;
/**
* The maximum number of iterations or elements to compute
*/
public static final int MAX_ITER = COUNT;
/**
* The desired accuracy threshold or change in parameters at which the iterative algorithm is terminated.
*/
public static final int EPS = 2;
public int type;
public int maxCount;
public double epsilon;
/**
* Termination criteria for iterative algorithms.
*
* @param type
* the type of termination criteria: COUNT, EPS or COUNT + EPS.
* @param maxCount
* the maximum number of iterations/elements.
* @param epsilon
* the desired accuracy.
*/
public TermCriteria(int type, int maxCount, double epsilon) {
this.type = type;
this.maxCount = maxCount;
this.epsilon = epsilon;
}
/**
* Termination criteria for iterative algorithms.
*/
public TermCriteria() {
this(0, 0, 0.0);
}
public TermCriteria(double[] vals) {
set(vals);
}
public void set(double[] vals) {
if (vals != null) {
type = vals.length > 0 ? (int) vals[0] : 0;
maxCount = vals.length > 1 ? (int) vals[1] : 0;
epsilon = vals.length > 2 ? (double) vals[2] : 0;
} else {
type = 0;
maxCount = 0;
epsilon = 0;
}
}
public TermCriteria clone() {
return new TermCriteria(type, maxCount, epsilon);
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
long temp;
temp = Double.doubleToLongBits(type);
result = prime * result + (int) (temp ^ (temp >>> 32));
temp = Double.doubleToLongBits(maxCount);
result = prime * result + (int) (temp ^ (temp >>> 32));
temp = Double.doubleToLongBits(epsilon);
result = prime * result + (int) (temp ^ (temp >>> 32));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (!(obj instanceof TermCriteria)) return false;
TermCriteria it = (TermCriteria) obj;
return type == it.type && maxCount == it.maxCount && epsilon == it.epsilon;
}
@Override
public String toString() {
return "{ type: " + type + ", maxCount: " + maxCount + ", epsilon: " + epsilon + "}";
}
}
| 2,607 | 27.043011 | 109 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/objdetect/Objdetect.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.objdetect;
import java.util.ArrayList;
import org.opencv.core.Mat;
import org.opencv.core.MatOfInt;
import org.opencv.core.MatOfRect;
public class Objdetect {
public static final int
CASCADE_DO_CANNY_PRUNING = 1,
CASCADE_SCALE_IMAGE = 2,
CASCADE_FIND_BIGGEST_OBJECT = 4,
CASCADE_DO_ROUGH_SEARCH = 8;
//
// C++: void groupRectangles(vector_Rect& rectList, vector_int& weights, int groupThreshold, double eps = 0.2)
//
//javadoc: groupRectangles(rectList, weights, groupThreshold, eps)
public static void groupRectangles(MatOfRect rectList, MatOfInt weights, int groupThreshold, double eps)
{
Mat rectList_mat = rectList;
Mat weights_mat = weights;
groupRectangles_0(rectList_mat.nativeObj, weights_mat.nativeObj, groupThreshold, eps);
return;
}
//javadoc: groupRectangles(rectList, weights, groupThreshold)
public static void groupRectangles(MatOfRect rectList, MatOfInt weights, int groupThreshold)
{
Mat rectList_mat = rectList;
Mat weights_mat = weights;
groupRectangles_1(rectList_mat.nativeObj, weights_mat.nativeObj, groupThreshold);
return;
}
// C++: void groupRectangles(vector_Rect& rectList, vector_int& weights, int groupThreshold, double eps = 0.2)
private static native void groupRectangles_0(long rectList_mat_nativeObj, long weights_mat_nativeObj, int groupThreshold, double eps);
private static native void groupRectangles_1(long rectList_mat_nativeObj, long weights_mat_nativeObj, int groupThreshold);
}
| 1,706 | 31.207547 | 138 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/objdetect/CascadeClassifier.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.objdetect;
import java.lang.String;
import java.util.ArrayList;
import org.opencv.core.Mat;
import org.opencv.core.MatOfDouble;
import org.opencv.core.MatOfInt;
import org.opencv.core.MatOfRect;
import org.opencv.core.Size;
// C++: class CascadeClassifier
//javadoc: CascadeClassifier
public class CascadeClassifier {
protected final long nativeObj;
protected CascadeClassifier(long addr) { nativeObj = addr; }
//
// C++: CascadeClassifier(String filename)
//
//javadoc: CascadeClassifier::CascadeClassifier(filename)
public CascadeClassifier(String filename)
{
nativeObj = CascadeClassifier_0(filename);
return;
}
//
// C++: CascadeClassifier()
//
//javadoc: CascadeClassifier::CascadeClassifier()
public CascadeClassifier()
{
nativeObj = CascadeClassifier_1();
return;
}
//
// C++: Size getOriginalWindowSize()
//
//javadoc: CascadeClassifier::getOriginalWindowSize()
public Size getOriginalWindowSize()
{
Size retVal = new Size(getOriginalWindowSize_0(nativeObj));
return retVal;
}
//
// C++: static bool convert(String oldcascade, String newcascade)
//
//javadoc: CascadeClassifier::convert(oldcascade, newcascade)
public static boolean convert(String oldcascade, String newcascade)
{
boolean retVal = convert_0(oldcascade, newcascade);
return retVal;
}
//
// C++: bool empty()
//
//javadoc: CascadeClassifier::empty()
public boolean empty()
{
boolean retVal = empty_0(nativeObj);
return retVal;
}
//
// C++: bool isOldFormatCascade()
//
//javadoc: CascadeClassifier::isOldFormatCascade()
public boolean isOldFormatCascade()
{
boolean retVal = isOldFormatCascade_0(nativeObj);
return retVal;
}
//
// C++: bool load(String filename)
//
//javadoc: CascadeClassifier::load(filename)
public boolean load(String filename)
{
boolean retVal = load_0(nativeObj, filename);
return retVal;
}
//
// C++: bool read(FileNode node)
//
// Unknown type 'FileNode' (I), skipping the function
//
// C++: int getFeatureType()
//
//javadoc: CascadeClassifier::getFeatureType()
public int getFeatureType()
{
int retVal = getFeatureType_0(nativeObj);
return retVal;
}
//
// C++: void detectMultiScale(Mat image, vector_Rect& objects, double scaleFactor = 1.1, int minNeighbors = 3, int flags = 0, Size minSize = Size(), Size maxSize = Size())
//
//javadoc: CascadeClassifier::detectMultiScale(image, objects, scaleFactor, minNeighbors, flags, minSize, maxSize)
public void detectMultiScale(Mat image, MatOfRect objects, double scaleFactor, int minNeighbors, int flags, Size minSize, Size maxSize)
{
Mat objects_mat = objects;
detectMultiScale_0(nativeObj, image.nativeObj, objects_mat.nativeObj, scaleFactor, minNeighbors, flags, minSize.width, minSize.height, maxSize.width, maxSize.height);
return;
}
//javadoc: CascadeClassifier::detectMultiScale(image, objects)
public void detectMultiScale(Mat image, MatOfRect objects)
{
Mat objects_mat = objects;
detectMultiScale_1(nativeObj, image.nativeObj, objects_mat.nativeObj);
return;
}
//
// C++: void detectMultiScale(Mat image, vector_Rect& objects, vector_int& numDetections, double scaleFactor = 1.1, int minNeighbors = 3, int flags = 0, Size minSize = Size(), Size maxSize = Size())
//
//javadoc: CascadeClassifier::detectMultiScale(image, objects, numDetections, scaleFactor, minNeighbors, flags, minSize, maxSize)
public void detectMultiScale2(Mat image, MatOfRect objects, MatOfInt numDetections, double scaleFactor, int minNeighbors, int flags, Size minSize, Size maxSize)
{
Mat objects_mat = objects;
Mat numDetections_mat = numDetections;
detectMultiScale2_0(nativeObj, image.nativeObj, objects_mat.nativeObj, numDetections_mat.nativeObj, scaleFactor, minNeighbors, flags, minSize.width, minSize.height, maxSize.width, maxSize.height);
return;
}
//javadoc: CascadeClassifier::detectMultiScale(image, objects, numDetections)
public void detectMultiScale2(Mat image, MatOfRect objects, MatOfInt numDetections)
{
Mat objects_mat = objects;
Mat numDetections_mat = numDetections;
detectMultiScale2_1(nativeObj, image.nativeObj, objects_mat.nativeObj, numDetections_mat.nativeObj);
return;
}
//
// C++: void detectMultiScale(Mat image, vector_Rect& objects, vector_int& rejectLevels, vector_double& levelWeights, double scaleFactor = 1.1, int minNeighbors = 3, int flags = 0, Size minSize = Size(), Size maxSize = Size(), bool outputRejectLevels = false)
//
//javadoc: CascadeClassifier::detectMultiScale(image, objects, rejectLevels, levelWeights, scaleFactor, minNeighbors, flags, minSize, maxSize, outputRejectLevels)
public void detectMultiScale3(Mat image, MatOfRect objects, MatOfInt rejectLevels, MatOfDouble levelWeights, double scaleFactor, int minNeighbors, int flags, Size minSize, Size maxSize, boolean outputRejectLevels)
{
Mat objects_mat = objects;
Mat rejectLevels_mat = rejectLevels;
Mat levelWeights_mat = levelWeights;
detectMultiScale3_0(nativeObj, image.nativeObj, objects_mat.nativeObj, rejectLevels_mat.nativeObj, levelWeights_mat.nativeObj, scaleFactor, minNeighbors, flags, minSize.width, minSize.height, maxSize.width, maxSize.height, outputRejectLevels);
return;
}
//javadoc: CascadeClassifier::detectMultiScale(image, objects, rejectLevels, levelWeights)
public void detectMultiScale3(Mat image, MatOfRect objects, MatOfInt rejectLevels, MatOfDouble levelWeights)
{
Mat objects_mat = objects;
Mat rejectLevels_mat = rejectLevels;
Mat levelWeights_mat = levelWeights;
detectMultiScale3_1(nativeObj, image.nativeObj, objects_mat.nativeObj, rejectLevels_mat.nativeObj, levelWeights_mat.nativeObj);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: CascadeClassifier(String filename)
private static native long CascadeClassifier_0(String filename);
// C++: CascadeClassifier()
private static native long CascadeClassifier_1();
// C++: Size getOriginalWindowSize()
private static native double[] getOriginalWindowSize_0(long nativeObj);
// C++: static bool convert(String oldcascade, String newcascade)
private static native boolean convert_0(String oldcascade, String newcascade);
// C++: bool empty()
private static native boolean empty_0(long nativeObj);
// C++: bool isOldFormatCascade()
private static native boolean isOldFormatCascade_0(long nativeObj);
// C++: bool load(String filename)
private static native boolean load_0(long nativeObj, String filename);
// C++: int getFeatureType()
private static native int getFeatureType_0(long nativeObj);
// C++: void detectMultiScale(Mat image, vector_Rect& objects, double scaleFactor = 1.1, int minNeighbors = 3, int flags = 0, Size minSize = Size(), Size maxSize = Size())
private static native void detectMultiScale_0(long nativeObj, long image_nativeObj, long objects_mat_nativeObj, double scaleFactor, int minNeighbors, int flags, double minSize_width, double minSize_height, double maxSize_width, double maxSize_height);
private static native void detectMultiScale_1(long nativeObj, long image_nativeObj, long objects_mat_nativeObj);
// C++: void detectMultiScale(Mat image, vector_Rect& objects, vector_int& numDetections, double scaleFactor = 1.1, int minNeighbors = 3, int flags = 0, Size minSize = Size(), Size maxSize = Size())
private static native void detectMultiScale2_0(long nativeObj, long image_nativeObj, long objects_mat_nativeObj, long numDetections_mat_nativeObj, double scaleFactor, int minNeighbors, int flags, double minSize_width, double minSize_height, double maxSize_width, double maxSize_height);
private static native void detectMultiScale2_1(long nativeObj, long image_nativeObj, long objects_mat_nativeObj, long numDetections_mat_nativeObj);
// C++: void detectMultiScale(Mat image, vector_Rect& objects, vector_int& rejectLevels, vector_double& levelWeights, double scaleFactor = 1.1, int minNeighbors = 3, int flags = 0, Size minSize = Size(), Size maxSize = Size(), bool outputRejectLevels = false)
private static native void detectMultiScale3_0(long nativeObj, long image_nativeObj, long objects_mat_nativeObj, long rejectLevels_mat_nativeObj, long levelWeights_mat_nativeObj, double scaleFactor, int minNeighbors, int flags, double minSize_width, double minSize_height, double maxSize_width, double maxSize_height, boolean outputRejectLevels);
private static native void detectMultiScale3_1(long nativeObj, long image_nativeObj, long objects_mat_nativeObj, long rejectLevels_mat_nativeObj, long levelWeights_mat_nativeObj);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 9,615 | 35.424242 | 350 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/objdetect/BaseCascadeClassifier.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.objdetect;
import org.opencv.core.Algorithm;
// C++: class BaseCascadeClassifier
//javadoc: BaseCascadeClassifier
public class BaseCascadeClassifier extends Algorithm {
protected BaseCascadeClassifier(long addr) { super(addr); }
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 519 | 18.259259 | 63 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/objdetect/HOGDescriptor.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.objdetect;
import java.lang.String;
import java.util.ArrayList;
import org.opencv.core.Mat;
import org.opencv.core.MatOfDouble;
import org.opencv.core.MatOfFloat;
import org.opencv.core.MatOfPoint;
import org.opencv.core.MatOfRect;
import org.opencv.core.Size;
// C++: class HOGDescriptor
//javadoc: HOGDescriptor
public class HOGDescriptor {
protected final long nativeObj;
protected HOGDescriptor(long addr) { nativeObj = addr; }
public static final int
L2Hys = 0,
DEFAULT_NLEVELS = 64;
//
// C++: HOGDescriptor(Size _winSize, Size _blockSize, Size _blockStride, Size _cellSize, int _nbins, int _derivAperture = 1, double _winSigma = -1, int _histogramNormType = HOGDescriptor::L2Hys, double _L2HysThreshold = 0.2, bool _gammaCorrection = false, int _nlevels = HOGDescriptor::DEFAULT_NLEVELS, bool _signedGradient = false)
//
//javadoc: HOGDescriptor::HOGDescriptor(_winSize, _blockSize, _blockStride, _cellSize, _nbins, _derivAperture, _winSigma, _histogramNormType, _L2HysThreshold, _gammaCorrection, _nlevels, _signedGradient)
public HOGDescriptor(Size _winSize, Size _blockSize, Size _blockStride, Size _cellSize, int _nbins, int _derivAperture, double _winSigma, int _histogramNormType, double _L2HysThreshold, boolean _gammaCorrection, int _nlevels, boolean _signedGradient)
{
nativeObj = HOGDescriptor_0(_winSize.width, _winSize.height, _blockSize.width, _blockSize.height, _blockStride.width, _blockStride.height, _cellSize.width, _cellSize.height, _nbins, _derivAperture, _winSigma, _histogramNormType, _L2HysThreshold, _gammaCorrection, _nlevels, _signedGradient);
return;
}
//javadoc: HOGDescriptor::HOGDescriptor(_winSize, _blockSize, _blockStride, _cellSize, _nbins)
public HOGDescriptor(Size _winSize, Size _blockSize, Size _blockStride, Size _cellSize, int _nbins)
{
nativeObj = HOGDescriptor_1(_winSize.width, _winSize.height, _blockSize.width, _blockSize.height, _blockStride.width, _blockStride.height, _cellSize.width, _cellSize.height, _nbins);
return;
}
//
// C++: HOGDescriptor(String filename)
//
//javadoc: HOGDescriptor::HOGDescriptor(filename)
public HOGDescriptor(String filename)
{
nativeObj = HOGDescriptor_2(filename);
return;
}
//
// C++: HOGDescriptor()
//
//javadoc: HOGDescriptor::HOGDescriptor()
public HOGDescriptor()
{
nativeObj = HOGDescriptor_3();
return;
}
//
// C++: bool checkDetectorSize()
//
//javadoc: HOGDescriptor::checkDetectorSize()
public boolean checkDetectorSize()
{
boolean retVal = checkDetectorSize_0(nativeObj);
return retVal;
}
//
// C++: bool load(String filename, String objname = String())
//
//javadoc: HOGDescriptor::load(filename, objname)
public boolean load(String filename, String objname)
{
boolean retVal = load_0(nativeObj, filename, objname);
return retVal;
}
//javadoc: HOGDescriptor::load(filename)
public boolean load(String filename)
{
boolean retVal = load_1(nativeObj, filename);
return retVal;
}
//
// C++: double getWinSigma()
//
//javadoc: HOGDescriptor::getWinSigma()
public double getWinSigma()
{
double retVal = getWinSigma_0(nativeObj);
return retVal;
}
//
// C++: size_t getDescriptorSize()
//
//javadoc: HOGDescriptor::getDescriptorSize()
public long getDescriptorSize()
{
long retVal = getDescriptorSize_0(nativeObj);
return retVal;
}
//
// C++: static vector_float getDaimlerPeopleDetector()
//
//javadoc: HOGDescriptor::getDaimlerPeopleDetector()
public static MatOfFloat getDaimlerPeopleDetector()
{
MatOfFloat retVal = MatOfFloat.fromNativeAddr(getDaimlerPeopleDetector_0());
return retVal;
}
//
// C++: static vector_float getDefaultPeopleDetector()
//
//javadoc: HOGDescriptor::getDefaultPeopleDetector()
public static MatOfFloat getDefaultPeopleDetector()
{
MatOfFloat retVal = MatOfFloat.fromNativeAddr(getDefaultPeopleDetector_0());
return retVal;
}
//
// C++: void compute(Mat img, vector_float& descriptors, Size winStride = Size(), Size padding = Size(), vector_Point locations = std::vector<Point>())
//
//javadoc: HOGDescriptor::compute(img, descriptors, winStride, padding, locations)
public void compute(Mat img, MatOfFloat descriptors, Size winStride, Size padding, MatOfPoint locations)
{
Mat descriptors_mat = descriptors;
Mat locations_mat = locations;
compute_0(nativeObj, img.nativeObj, descriptors_mat.nativeObj, winStride.width, winStride.height, padding.width, padding.height, locations_mat.nativeObj);
return;
}
//javadoc: HOGDescriptor::compute(img, descriptors)
public void compute(Mat img, MatOfFloat descriptors)
{
Mat descriptors_mat = descriptors;
compute_1(nativeObj, img.nativeObj, descriptors_mat.nativeObj);
return;
}
//
// C++: void computeGradient(Mat img, Mat& grad, Mat& angleOfs, Size paddingTL = Size(), Size paddingBR = Size())
//
//javadoc: HOGDescriptor::computeGradient(img, grad, angleOfs, paddingTL, paddingBR)
public void computeGradient(Mat img, Mat grad, Mat angleOfs, Size paddingTL, Size paddingBR)
{
computeGradient_0(nativeObj, img.nativeObj, grad.nativeObj, angleOfs.nativeObj, paddingTL.width, paddingTL.height, paddingBR.width, paddingBR.height);
return;
}
//javadoc: HOGDescriptor::computeGradient(img, grad, angleOfs)
public void computeGradient(Mat img, Mat grad, Mat angleOfs)
{
computeGradient_1(nativeObj, img.nativeObj, grad.nativeObj, angleOfs.nativeObj);
return;
}
//
// C++: void detect(Mat img, vector_Point& foundLocations, vector_double& weights, double hitThreshold = 0, Size winStride = Size(), Size padding = Size(), vector_Point searchLocations = std::vector<Point>())
//
//javadoc: HOGDescriptor::detect(img, foundLocations, weights, hitThreshold, winStride, padding, searchLocations)
public void detect(Mat img, MatOfPoint foundLocations, MatOfDouble weights, double hitThreshold, Size winStride, Size padding, MatOfPoint searchLocations)
{
Mat foundLocations_mat = foundLocations;
Mat weights_mat = weights;
Mat searchLocations_mat = searchLocations;
detect_0(nativeObj, img.nativeObj, foundLocations_mat.nativeObj, weights_mat.nativeObj, hitThreshold, winStride.width, winStride.height, padding.width, padding.height, searchLocations_mat.nativeObj);
return;
}
//javadoc: HOGDescriptor::detect(img, foundLocations, weights)
public void detect(Mat img, MatOfPoint foundLocations, MatOfDouble weights)
{
Mat foundLocations_mat = foundLocations;
Mat weights_mat = weights;
detect_1(nativeObj, img.nativeObj, foundLocations_mat.nativeObj, weights_mat.nativeObj);
return;
}
//
// C++: void detectMultiScale(Mat img, vector_Rect& foundLocations, vector_double& foundWeights, double hitThreshold = 0, Size winStride = Size(), Size padding = Size(), double scale = 1.05, double finalThreshold = 2.0, bool useMeanshiftGrouping = false)
//
//javadoc: HOGDescriptor::detectMultiScale(img, foundLocations, foundWeights, hitThreshold, winStride, padding, scale, finalThreshold, useMeanshiftGrouping)
public void detectMultiScale(Mat img, MatOfRect foundLocations, MatOfDouble foundWeights, double hitThreshold, Size winStride, Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)
{
Mat foundLocations_mat = foundLocations;
Mat foundWeights_mat = foundWeights;
detectMultiScale_0(nativeObj, img.nativeObj, foundLocations_mat.nativeObj, foundWeights_mat.nativeObj, hitThreshold, winStride.width, winStride.height, padding.width, padding.height, scale, finalThreshold, useMeanshiftGrouping);
return;
}
//javadoc: HOGDescriptor::detectMultiScale(img, foundLocations, foundWeights)
public void detectMultiScale(Mat img, MatOfRect foundLocations, MatOfDouble foundWeights)
{
Mat foundLocations_mat = foundLocations;
Mat foundWeights_mat = foundWeights;
detectMultiScale_1(nativeObj, img.nativeObj, foundLocations_mat.nativeObj, foundWeights_mat.nativeObj);
return;
}
//
// C++: void save(String filename, String objname = String())
//
//javadoc: HOGDescriptor::save(filename, objname)
public void save(String filename, String objname)
{
save_0(nativeObj, filename, objname);
return;
}
//javadoc: HOGDescriptor::save(filename)
public void save(String filename)
{
save_1(nativeObj, filename);
return;
}
//
// C++: void setSVMDetector(Mat _svmdetector)
//
//javadoc: HOGDescriptor::setSVMDetector(_svmdetector)
public void setSVMDetector(Mat _svmdetector)
{
setSVMDetector_0(nativeObj, _svmdetector.nativeObj);
return;
}
//
// C++: Size HOGDescriptor::winSize
//
//javadoc: HOGDescriptor::get_winSize()
public Size get_winSize()
{
Size retVal = new Size(get_winSize_0(nativeObj));
return retVal;
}
//
// C++: Size HOGDescriptor::blockSize
//
//javadoc: HOGDescriptor::get_blockSize()
public Size get_blockSize()
{
Size retVal = new Size(get_blockSize_0(nativeObj));
return retVal;
}
//
// C++: Size HOGDescriptor::blockStride
//
//javadoc: HOGDescriptor::get_blockStride()
public Size get_blockStride()
{
Size retVal = new Size(get_blockStride_0(nativeObj));
return retVal;
}
//
// C++: Size HOGDescriptor::cellSize
//
//javadoc: HOGDescriptor::get_cellSize()
public Size get_cellSize()
{
Size retVal = new Size(get_cellSize_0(nativeObj));
return retVal;
}
//
// C++: int HOGDescriptor::nbins
//
//javadoc: HOGDescriptor::get_nbins()
public int get_nbins()
{
int retVal = get_nbins_0(nativeObj);
return retVal;
}
//
// C++: int HOGDescriptor::derivAperture
//
//javadoc: HOGDescriptor::get_derivAperture()
public int get_derivAperture()
{
int retVal = get_derivAperture_0(nativeObj);
return retVal;
}
//
// C++: double HOGDescriptor::winSigma
//
//javadoc: HOGDescriptor::get_winSigma()
public double get_winSigma()
{
double retVal = get_winSigma_0(nativeObj);
return retVal;
}
//
// C++: int HOGDescriptor::histogramNormType
//
//javadoc: HOGDescriptor::get_histogramNormType()
public int get_histogramNormType()
{
int retVal = get_histogramNormType_0(nativeObj);
return retVal;
}
//
// C++: double HOGDescriptor::L2HysThreshold
//
//javadoc: HOGDescriptor::get_L2HysThreshold()
public double get_L2HysThreshold()
{
double retVal = get_L2HysThreshold_0(nativeObj);
return retVal;
}
//
// C++: bool HOGDescriptor::gammaCorrection
//
//javadoc: HOGDescriptor::get_gammaCorrection()
public boolean get_gammaCorrection()
{
boolean retVal = get_gammaCorrection_0(nativeObj);
return retVal;
}
//
// C++: vector_float HOGDescriptor::svmDetector
//
//javadoc: HOGDescriptor::get_svmDetector()
public MatOfFloat get_svmDetector()
{
MatOfFloat retVal = MatOfFloat.fromNativeAddr(get_svmDetector_0(nativeObj));
return retVal;
}
//
// C++: int HOGDescriptor::nlevels
//
//javadoc: HOGDescriptor::get_nlevels()
public int get_nlevels()
{
int retVal = get_nlevels_0(nativeObj);
return retVal;
}
//
// C++: bool HOGDescriptor::signedGradient
//
//javadoc: HOGDescriptor::get_signedGradient()
public boolean get_signedGradient()
{
boolean retVal = get_signedGradient_0(nativeObj);
return retVal;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: HOGDescriptor(Size _winSize, Size _blockSize, Size _blockStride, Size _cellSize, int _nbins, int _derivAperture = 1, double _winSigma = -1, int _histogramNormType = HOGDescriptor::L2Hys, double _L2HysThreshold = 0.2, bool _gammaCorrection = false, int _nlevels = HOGDescriptor::DEFAULT_NLEVELS, bool _signedGradient = false)
private static native long HOGDescriptor_0(double _winSize_width, double _winSize_height, double _blockSize_width, double _blockSize_height, double _blockStride_width, double _blockStride_height, double _cellSize_width, double _cellSize_height, int _nbins, int _derivAperture, double _winSigma, int _histogramNormType, double _L2HysThreshold, boolean _gammaCorrection, int _nlevels, boolean _signedGradient);
private static native long HOGDescriptor_1(double _winSize_width, double _winSize_height, double _blockSize_width, double _blockSize_height, double _blockStride_width, double _blockStride_height, double _cellSize_width, double _cellSize_height, int _nbins);
// C++: HOGDescriptor(String filename)
private static native long HOGDescriptor_2(String filename);
// C++: HOGDescriptor()
private static native long HOGDescriptor_3();
// C++: bool checkDetectorSize()
private static native boolean checkDetectorSize_0(long nativeObj);
// C++: bool load(String filename, String objname = String())
private static native boolean load_0(long nativeObj, String filename, String objname);
private static native boolean load_1(long nativeObj, String filename);
// C++: double getWinSigma()
private static native double getWinSigma_0(long nativeObj);
// C++: size_t getDescriptorSize()
private static native long getDescriptorSize_0(long nativeObj);
// C++: static vector_float getDaimlerPeopleDetector()
private static native long getDaimlerPeopleDetector_0();
// C++: static vector_float getDefaultPeopleDetector()
private static native long getDefaultPeopleDetector_0();
// C++: void compute(Mat img, vector_float& descriptors, Size winStride = Size(), Size padding = Size(), vector_Point locations = std::vector<Point>())
private static native void compute_0(long nativeObj, long img_nativeObj, long descriptors_mat_nativeObj, double winStride_width, double winStride_height, double padding_width, double padding_height, long locations_mat_nativeObj);
private static native void compute_1(long nativeObj, long img_nativeObj, long descriptors_mat_nativeObj);
// C++: void computeGradient(Mat img, Mat& grad, Mat& angleOfs, Size paddingTL = Size(), Size paddingBR = Size())
private static native void computeGradient_0(long nativeObj, long img_nativeObj, long grad_nativeObj, long angleOfs_nativeObj, double paddingTL_width, double paddingTL_height, double paddingBR_width, double paddingBR_height);
private static native void computeGradient_1(long nativeObj, long img_nativeObj, long grad_nativeObj, long angleOfs_nativeObj);
// C++: void detect(Mat img, vector_Point& foundLocations, vector_double& weights, double hitThreshold = 0, Size winStride = Size(), Size padding = Size(), vector_Point searchLocations = std::vector<Point>())
private static native void detect_0(long nativeObj, long img_nativeObj, long foundLocations_mat_nativeObj, long weights_mat_nativeObj, double hitThreshold, double winStride_width, double winStride_height, double padding_width, double padding_height, long searchLocations_mat_nativeObj);
private static native void detect_1(long nativeObj, long img_nativeObj, long foundLocations_mat_nativeObj, long weights_mat_nativeObj);
// C++: void detectMultiScale(Mat img, vector_Rect& foundLocations, vector_double& foundWeights, double hitThreshold = 0, Size winStride = Size(), Size padding = Size(), double scale = 1.05, double finalThreshold = 2.0, bool useMeanshiftGrouping = false)
private static native void detectMultiScale_0(long nativeObj, long img_nativeObj, long foundLocations_mat_nativeObj, long foundWeights_mat_nativeObj, double hitThreshold, double winStride_width, double winStride_height, double padding_width, double padding_height, double scale, double finalThreshold, boolean useMeanshiftGrouping);
private static native void detectMultiScale_1(long nativeObj, long img_nativeObj, long foundLocations_mat_nativeObj, long foundWeights_mat_nativeObj);
// C++: void save(String filename, String objname = String())
private static native void save_0(long nativeObj, String filename, String objname);
private static native void save_1(long nativeObj, String filename);
// C++: void setSVMDetector(Mat _svmdetector)
private static native void setSVMDetector_0(long nativeObj, long _svmdetector_nativeObj);
// C++: Size HOGDescriptor::winSize
private static native double[] get_winSize_0(long nativeObj);
// C++: Size HOGDescriptor::blockSize
private static native double[] get_blockSize_0(long nativeObj);
// C++: Size HOGDescriptor::blockStride
private static native double[] get_blockStride_0(long nativeObj);
// C++: Size HOGDescriptor::cellSize
private static native double[] get_cellSize_0(long nativeObj);
// C++: int HOGDescriptor::nbins
private static native int get_nbins_0(long nativeObj);
// C++: int HOGDescriptor::derivAperture
private static native int get_derivAperture_0(long nativeObj);
// C++: double HOGDescriptor::winSigma
private static native double get_winSigma_0(long nativeObj);
// C++: int HOGDescriptor::histogramNormType
private static native int get_histogramNormType_0(long nativeObj);
// C++: double HOGDescriptor::L2HysThreshold
private static native double get_L2HysThreshold_0(long nativeObj);
// C++: bool HOGDescriptor::gammaCorrection
private static native boolean get_gammaCorrection_0(long nativeObj);
// C++: vector_float HOGDescriptor::svmDetector
private static native long get_svmDetector_0(long nativeObj);
// C++: int HOGDescriptor::nlevels
private static native int get_nlevels_0(long nativeObj);
// C++: bool HOGDescriptor::signedGradient
private static native boolean get_signedGradient_0(long nativeObj);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 19,474 | 31.896959 | 412 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/imgproc/Subdiv2D.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.imgproc;
import java.util.ArrayList;
import java.util.List;
import org.opencv.core.Mat;
import org.opencv.core.MatOfFloat4;
import org.opencv.core.MatOfFloat6;
import org.opencv.core.MatOfInt;
import org.opencv.core.MatOfPoint2f;
import org.opencv.core.Point;
import org.opencv.core.Rect;
import org.opencv.utils.Converters;
// C++: class Subdiv2D
//javadoc: Subdiv2D
public class Subdiv2D {
protected final long nativeObj;
protected Subdiv2D(long addr) { nativeObj = addr; }
public static final int
PTLOC_ERROR = -2,
PTLOC_OUTSIDE_RECT = -1,
PTLOC_INSIDE = 0,
PTLOC_VERTEX = 1,
PTLOC_ON_EDGE = 2,
NEXT_AROUND_ORG = 0x00,
NEXT_AROUND_DST = 0x22,
PREV_AROUND_ORG = 0x11,
PREV_AROUND_DST = 0x33,
NEXT_AROUND_LEFT = 0x13,
NEXT_AROUND_RIGHT = 0x31,
PREV_AROUND_LEFT = 0x20,
PREV_AROUND_RIGHT = 0x02;
//
// C++: Subdiv2D(Rect rect)
//
//javadoc: Subdiv2D::Subdiv2D(rect)
public Subdiv2D(Rect rect)
{
nativeObj = Subdiv2D_0(rect.x, rect.y, rect.width, rect.height);
return;
}
//
// C++: Subdiv2D()
//
//javadoc: Subdiv2D::Subdiv2D()
public Subdiv2D()
{
nativeObj = Subdiv2D_1();
return;
}
//
// C++: Point2f getVertex(int vertex, int* firstEdge = 0)
//
//javadoc: Subdiv2D::getVertex(vertex, firstEdge)
public Point getVertex(int vertex, int[] firstEdge)
{
double[] firstEdge_out = new double[1];
Point retVal = new Point(getVertex_0(nativeObj, vertex, firstEdge_out));
if(firstEdge!=null) firstEdge[0] = (int)firstEdge_out[0];
return retVal;
}
//javadoc: Subdiv2D::getVertex(vertex)
public Point getVertex(int vertex)
{
Point retVal = new Point(getVertex_1(nativeObj, vertex));
return retVal;
}
//
// C++: int edgeDst(int edge, Point2f* dstpt = 0)
//
//javadoc: Subdiv2D::edgeDst(edge, dstpt)
public int edgeDst(int edge, Point dstpt)
{
double[] dstpt_out = new double[2];
int retVal = edgeDst_0(nativeObj, edge, dstpt_out);
if(dstpt!=null){ dstpt.x = dstpt_out[0]; dstpt.y = dstpt_out[1]; }
return retVal;
}
//javadoc: Subdiv2D::edgeDst(edge)
public int edgeDst(int edge)
{
int retVal = edgeDst_1(nativeObj, edge);
return retVal;
}
//
// C++: int edgeOrg(int edge, Point2f* orgpt = 0)
//
//javadoc: Subdiv2D::edgeOrg(edge, orgpt)
public int edgeOrg(int edge, Point orgpt)
{
double[] orgpt_out = new double[2];
int retVal = edgeOrg_0(nativeObj, edge, orgpt_out);
if(orgpt!=null){ orgpt.x = orgpt_out[0]; orgpt.y = orgpt_out[1]; }
return retVal;
}
//javadoc: Subdiv2D::edgeOrg(edge)
public int edgeOrg(int edge)
{
int retVal = edgeOrg_1(nativeObj, edge);
return retVal;
}
//
// C++: int findNearest(Point2f pt, Point2f* nearestPt = 0)
//
//javadoc: Subdiv2D::findNearest(pt, nearestPt)
public int findNearest(Point pt, Point nearestPt)
{
double[] nearestPt_out = new double[2];
int retVal = findNearest_0(nativeObj, pt.x, pt.y, nearestPt_out);
if(nearestPt!=null){ nearestPt.x = nearestPt_out[0]; nearestPt.y = nearestPt_out[1]; }
return retVal;
}
//javadoc: Subdiv2D::findNearest(pt)
public int findNearest(Point pt)
{
int retVal = findNearest_1(nativeObj, pt.x, pt.y);
return retVal;
}
//
// C++: int getEdge(int edge, int nextEdgeType)
//
//javadoc: Subdiv2D::getEdge(edge, nextEdgeType)
public int getEdge(int edge, int nextEdgeType)
{
int retVal = getEdge_0(nativeObj, edge, nextEdgeType);
return retVal;
}
//
// C++: int insert(Point2f pt)
//
//javadoc: Subdiv2D::insert(pt)
public int insert(Point pt)
{
int retVal = insert_0(nativeObj, pt.x, pt.y);
return retVal;
}
//
// C++: int locate(Point2f pt, int& edge, int& vertex)
//
//javadoc: Subdiv2D::locate(pt, edge, vertex)
public int locate(Point pt, int[] edge, int[] vertex)
{
double[] edge_out = new double[1];
double[] vertex_out = new double[1];
int retVal = locate_0(nativeObj, pt.x, pt.y, edge_out, vertex_out);
if(edge!=null) edge[0] = (int)edge_out[0];
if(vertex!=null) vertex[0] = (int)vertex_out[0];
return retVal;
}
//
// C++: int nextEdge(int edge)
//
//javadoc: Subdiv2D::nextEdge(edge)
public int nextEdge(int edge)
{
int retVal = nextEdge_0(nativeObj, edge);
return retVal;
}
//
// C++: int rotateEdge(int edge, int rotate)
//
//javadoc: Subdiv2D::rotateEdge(edge, rotate)
public int rotateEdge(int edge, int rotate)
{
int retVal = rotateEdge_0(nativeObj, edge, rotate);
return retVal;
}
//
// C++: int symEdge(int edge)
//
//javadoc: Subdiv2D::symEdge(edge)
public int symEdge(int edge)
{
int retVal = symEdge_0(nativeObj, edge);
return retVal;
}
//
// C++: void getEdgeList(vector_Vec4f& edgeList)
//
//javadoc: Subdiv2D::getEdgeList(edgeList)
public void getEdgeList(MatOfFloat4 edgeList)
{
Mat edgeList_mat = edgeList;
getEdgeList_0(nativeObj, edgeList_mat.nativeObj);
return;
}
//
// C++: void getTriangleList(vector_Vec6f& triangleList)
//
//javadoc: Subdiv2D::getTriangleList(triangleList)
public void getTriangleList(MatOfFloat6 triangleList)
{
Mat triangleList_mat = triangleList;
getTriangleList_0(nativeObj, triangleList_mat.nativeObj);
return;
}
//
// C++: void getVoronoiFacetList(vector_int idx, vector_vector_Point2f& facetList, vector_Point2f& facetCenters)
//
//javadoc: Subdiv2D::getVoronoiFacetList(idx, facetList, facetCenters)
public void getVoronoiFacetList(MatOfInt idx, List<MatOfPoint2f> facetList, MatOfPoint2f facetCenters)
{
Mat idx_mat = idx;
Mat facetList_mat = new Mat();
Mat facetCenters_mat = facetCenters;
getVoronoiFacetList_0(nativeObj, idx_mat.nativeObj, facetList_mat.nativeObj, facetCenters_mat.nativeObj);
Converters.Mat_to_vector_vector_Point2f(facetList_mat, facetList);
facetList_mat.release();
return;
}
//
// C++: void initDelaunay(Rect rect)
//
//javadoc: Subdiv2D::initDelaunay(rect)
public void initDelaunay(Rect rect)
{
initDelaunay_0(nativeObj, rect.x, rect.y, rect.width, rect.height);
return;
}
//
// C++: void insert(vector_Point2f ptvec)
//
//javadoc: Subdiv2D::insert(ptvec)
public void insert(MatOfPoint2f ptvec)
{
Mat ptvec_mat = ptvec;
insert_1(nativeObj, ptvec_mat.nativeObj);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: Subdiv2D(Rect rect)
private static native long Subdiv2D_0(int rect_x, int rect_y, int rect_width, int rect_height);
// C++: Subdiv2D()
private static native long Subdiv2D_1();
// C++: Point2f getVertex(int vertex, int* firstEdge = 0)
private static native double[] getVertex_0(long nativeObj, int vertex, double[] firstEdge_out);
private static native double[] getVertex_1(long nativeObj, int vertex);
// C++: int edgeDst(int edge, Point2f* dstpt = 0)
private static native int edgeDst_0(long nativeObj, int edge, double[] dstpt_out);
private static native int edgeDst_1(long nativeObj, int edge);
// C++: int edgeOrg(int edge, Point2f* orgpt = 0)
private static native int edgeOrg_0(long nativeObj, int edge, double[] orgpt_out);
private static native int edgeOrg_1(long nativeObj, int edge);
// C++: int findNearest(Point2f pt, Point2f* nearestPt = 0)
private static native int findNearest_0(long nativeObj, double pt_x, double pt_y, double[] nearestPt_out);
private static native int findNearest_1(long nativeObj, double pt_x, double pt_y);
// C++: int getEdge(int edge, int nextEdgeType)
private static native int getEdge_0(long nativeObj, int edge, int nextEdgeType);
// C++: int insert(Point2f pt)
private static native int insert_0(long nativeObj, double pt_x, double pt_y);
// C++: int locate(Point2f pt, int& edge, int& vertex)
private static native int locate_0(long nativeObj, double pt_x, double pt_y, double[] edge_out, double[] vertex_out);
// C++: int nextEdge(int edge)
private static native int nextEdge_0(long nativeObj, int edge);
// C++: int rotateEdge(int edge, int rotate)
private static native int rotateEdge_0(long nativeObj, int edge, int rotate);
// C++: int symEdge(int edge)
private static native int symEdge_0(long nativeObj, int edge);
// C++: void getEdgeList(vector_Vec4f& edgeList)
private static native void getEdgeList_0(long nativeObj, long edgeList_mat_nativeObj);
// C++: void getTriangleList(vector_Vec6f& triangleList)
private static native void getTriangleList_0(long nativeObj, long triangleList_mat_nativeObj);
// C++: void getVoronoiFacetList(vector_int idx, vector_vector_Point2f& facetList, vector_Point2f& facetCenters)
private static native void getVoronoiFacetList_0(long nativeObj, long idx_mat_nativeObj, long facetList_mat_nativeObj, long facetCenters_mat_nativeObj);
// C++: void initDelaunay(Rect rect)
private static native void initDelaunay_0(long nativeObj, int rect_x, int rect_y, int rect_width, int rect_height);
// C++: void insert(vector_Point2f ptvec)
private static native void insert_1(long nativeObj, long ptvec_mat_nativeObj);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 10,439 | 25.976744 | 156 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/imgproc/Moments.java | package org.opencv.imgproc;
import java.lang.Math;
//javadoc:Moments
public class Moments {
public double m00;
public double m10;
public double m01;
public double m20;
public double m11;
public double m02;
public double m30;
public double m21;
public double m12;
public double m03;
public double mu20;
public double mu11;
public double mu02;
public double mu30;
public double mu21;
public double mu12;
public double mu03;
public double nu20;
public double nu11;
public double nu02;
public double nu30;
public double nu21;
public double nu12;
public double nu03;
public Moments(
double m00,
double m10,
double m01,
double m20,
double m11,
double m02,
double m30,
double m21,
double m12,
double m03)
{
this.m00 = m00;
this.m10 = m10;
this.m01 = m01;
this.m20 = m20;
this.m11 = m11;
this.m02 = m02;
this.m30 = m30;
this.m21 = m21;
this.m12 = m12;
this.m03 = m03;
this.completeState();
}
public Moments() {
this(0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
}
public Moments(double[] vals) {
set(vals);
}
public void set(double[] vals) {
if (vals != null) {
m00 = vals.length > 0 ? (int) vals[0] : 0;
m10 = vals.length > 1 ? (int) vals[1] : 0;
m01 = vals.length > 2 ? (int) vals[2] : 0;
m20 = vals.length > 3 ? (int) vals[3] : 0;
m11 = vals.length > 4 ? (int) vals[4] : 0;
m02 = vals.length > 5 ? (int) vals[5] : 0;
m30 = vals.length > 6 ? (int) vals[6] : 0;
m21 = vals.length > 7 ? (int) vals[7] : 0;
m12 = vals.length > 8 ? (int) vals[8] : 0;
m03 = vals.length > 9 ? (int) vals[9] : 0;
this.completeState();
} else {
m00 = 0;
m10 = 0;
m01 = 0;
m20 = 0;
m11 = 0;
m02 = 0;
m30 = 0;
m21 = 0;
m12 = 0;
m03 = 0;
mu20 = 0;
mu11 = 0;
mu02 = 0;
mu30 = 0;
mu21 = 0;
mu12 = 0;
mu03 = 0;
nu20 = 0;
nu11 = 0;
nu02 = 0;
nu30 = 0;
nu21 = 0;
nu12 = 0;
nu03 = 0;
}
}
@Override
public String toString() {
return "Moments [ " +
"\n" +
"m00=" + m00 + ", " +
"\n" +
"m10=" + m10 + ", " +
"m01=" + m01 + ", " +
"\n" +
"m20=" + m20 + ", " +
"m11=" + m11 + ", " +
"m02=" + m02 + ", " +
"\n" +
"m30=" + m30 + ", " +
"m21=" + m21 + ", " +
"m12=" + m12 + ", " +
"m03=" + m03 + ", " +
"\n" +
"mu20=" + mu20 + ", " +
"mu11=" + mu11 + ", " +
"mu02=" + mu02 + ", " +
"\n" +
"mu30=" + mu30 + ", " +
"mu21=" + mu21 + ", " +
"mu12=" + mu12 + ", " +
"mu03=" + mu03 + ", " +
"\n" +
"nu20=" + nu20 + ", " +
"nu11=" + nu11 + ", " +
"nu02=" + nu02 + ", " +
"\n" +
"nu30=" + nu30 + ", " +
"nu21=" + nu21 + ", " +
"nu12=" + nu12 + ", " +
"nu03=" + nu03 + ", " +
"\n]";
}
protected void completeState()
{
double cx = 0, cy = 0;
double mu20, mu11, mu02;
double inv_m00 = 0.0;
if( Math.abs(this.m00) > 0.00000001 )
{
inv_m00 = 1. / this.m00;
cx = this.m10 * inv_m00;
cy = this.m01 * inv_m00;
}
// mu20 = m20 - m10*cx
mu20 = this.m20 - this.m10 * cx;
// mu11 = m11 - m10*cy
mu11 = this.m11 - this.m10 * cy;
// mu02 = m02 - m01*cy
mu02 = this.m02 - this.m01 * cy;
this.mu20 = mu20;
this.mu11 = mu11;
this.mu02 = mu02;
// mu30 = m30 - cx*(3*mu20 + cx*m10)
this.mu30 = this.m30 - cx * (3 * mu20 + cx * this.m10);
mu11 += mu11;
// mu21 = m21 - cx*(2*mu11 + cx*m01) - cy*mu20
this.mu21 = this.m21 - cx * (mu11 + cx * this.m01) - cy * mu20;
// mu12 = m12 - cy*(2*mu11 + cy*m10) - cx*mu02
this.mu12 = this.m12 - cy * (mu11 + cy * this.m10) - cx * mu02;
// mu03 = m03 - cy*(3*mu02 + cy*m01)
this.mu03 = this.m03 - cy * (3 * mu02 + cy * this.m01);
double inv_sqrt_m00 = Math.sqrt(Math.abs(inv_m00));
double s2 = inv_m00*inv_m00, s3 = s2*inv_sqrt_m00;
this.nu20 = this.mu20*s2;
this.nu11 = this.mu11*s2;
this.nu02 = this.mu02*s2;
this.nu30 = this.mu30*s3;
this.nu21 = this.mu21*s3;
this.nu12 = this.mu12*s3;
this.nu03 = this.mu03*s3;
}
public double get_m00() { return this.m00; }
public double get_m10() { return this.m10; }
public double get_m01() { return this.m01; }
public double get_m20() { return this.m20; }
public double get_m11() { return this.m11; }
public double get_m02() { return this.m02; }
public double get_m30() { return this.m30; }
public double get_m21() { return this.m21; }
public double get_m12() { return this.m12; }
public double get_m03() { return this.m03; }
public double get_mu20() { return this.mu20; }
public double get_mu11() { return this.mu11; }
public double get_mu02() { return this.mu02; }
public double get_mu30() { return this.mu30; }
public double get_mu21() { return this.mu21; }
public double get_mu12() { return this.mu12; }
public double get_mu03() { return this.mu03; }
public double get_nu20() { return this.nu20; }
public double get_nu11() { return this.nu11; }
public double get_nu02() { return this.nu02; }
public double get_nu30() { return this.nu30; }
public double get_nu21() { return this.nu21; }
public double get_nu12() { return this.nu12; }
public double get_nu03() { return this.nu03; }
public void set_m00(double m00) { this.m00 = m00; }
public void set_m10(double m10) { this.m10 = m10; }
public void set_m01(double m01) { this.m01 = m01; }
public void set_m20(double m20) { this.m20 = m20; }
public void set_m11(double m11) { this.m11 = m11; }
public void set_m02(double m02) { this.m02 = m02; }
public void set_m30(double m30) { this.m30 = m30; }
public void set_m21(double m21) { this.m21 = m21; }
public void set_m12(double m12) { this.m12 = m12; }
public void set_m03(double m03) { this.m03 = m03; }
public void set_mu20(double mu20) { this.mu20 = mu20; }
public void set_mu11(double mu11) { this.mu11 = mu11; }
public void set_mu02(double mu02) { this.mu02 = mu02; }
public void set_mu30(double mu30) { this.mu30 = mu30; }
public void set_mu21(double mu21) { this.mu21 = mu21; }
public void set_mu12(double mu12) { this.mu12 = mu12; }
public void set_mu03(double mu03) { this.mu03 = mu03; }
public void set_nu20(double nu20) { this.nu20 = nu20; }
public void set_nu11(double nu11) { this.nu11 = nu11; }
public void set_nu02(double nu02) { this.nu02 = nu02; }
public void set_nu30(double nu30) { this.nu30 = nu30; }
public void set_nu21(double nu21) { this.nu21 = nu21; }
public void set_nu12(double nu12) { this.nu12 = nu12; }
public void set_nu03(double nu03) { this.nu03 = nu03; }
}
| 7,680 | 30.35102 | 71 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/imgproc/LineSegmentDetector.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.imgproc;
import org.opencv.core.Algorithm;
import org.opencv.core.Mat;
import org.opencv.core.Size;
// C++: class LineSegmentDetector
//javadoc: LineSegmentDetector
public class LineSegmentDetector extends Algorithm {
protected LineSegmentDetector(long addr) { super(addr); }
//
// C++: int compareSegments(Size size, Mat lines1, Mat lines2, Mat& _image = Mat())
//
//javadoc: LineSegmentDetector::compareSegments(size, lines1, lines2, _image)
public int compareSegments(Size size, Mat lines1, Mat lines2, Mat _image)
{
int retVal = compareSegments_0(nativeObj, size.width, size.height, lines1.nativeObj, lines2.nativeObj, _image.nativeObj);
return retVal;
}
//javadoc: LineSegmentDetector::compareSegments(size, lines1, lines2)
public int compareSegments(Size size, Mat lines1, Mat lines2)
{
int retVal = compareSegments_1(nativeObj, size.width, size.height, lines1.nativeObj, lines2.nativeObj);
return retVal;
}
//
// C++: void detect(Mat _image, Mat& _lines, Mat& width = Mat(), Mat& prec = Mat(), Mat& nfa = Mat())
//
//javadoc: LineSegmentDetector::detect(_image, _lines, width, prec, nfa)
public void detect(Mat _image, Mat _lines, Mat width, Mat prec, Mat nfa)
{
detect_0(nativeObj, _image.nativeObj, _lines.nativeObj, width.nativeObj, prec.nativeObj, nfa.nativeObj);
return;
}
//javadoc: LineSegmentDetector::detect(_image, _lines)
public void detect(Mat _image, Mat _lines)
{
detect_1(nativeObj, _image.nativeObj, _lines.nativeObj);
return;
}
//
// C++: void drawSegments(Mat& _image, Mat lines)
//
//javadoc: LineSegmentDetector::drawSegments(_image, lines)
public void drawSegments(Mat _image, Mat lines)
{
drawSegments_0(nativeObj, _image.nativeObj, lines.nativeObj);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: int compareSegments(Size size, Mat lines1, Mat lines2, Mat& _image = Mat())
private static native int compareSegments_0(long nativeObj, double size_width, double size_height, long lines1_nativeObj, long lines2_nativeObj, long _image_nativeObj);
private static native int compareSegments_1(long nativeObj, double size_width, double size_height, long lines1_nativeObj, long lines2_nativeObj);
// C++: void detect(Mat _image, Mat& _lines, Mat& width = Mat(), Mat& prec = Mat(), Mat& nfa = Mat())
private static native void detect_0(long nativeObj, long _image_nativeObj, long _lines_nativeObj, long width_nativeObj, long prec_nativeObj, long nfa_nativeObj);
private static native void detect_1(long nativeObj, long _image_nativeObj, long _lines_nativeObj);
// C++: void drawSegments(Mat& _image, Mat lines)
private static native void drawSegments_0(long nativeObj, long _image_nativeObj, long lines_nativeObj);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 3,239 | 31.4 | 172 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/imgproc/Imgproc.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.imgproc;
import java.lang.String;
import java.util.ArrayList;
import java.util.List;
import org.opencv.core.Mat;
import org.opencv.core.MatOfFloat;
import org.opencv.core.MatOfInt;
import org.opencv.core.MatOfInt4;
import org.opencv.core.MatOfPoint;
import org.opencv.core.MatOfPoint2f;
import org.opencv.core.Point;
import org.opencv.core.Rect;
import org.opencv.core.RotatedRect;
import org.opencv.core.Scalar;
import org.opencv.core.Size;
import org.opencv.core.TermCriteria;
import org.opencv.utils.Converters;
public class Imgproc {
private static final int
IPL_BORDER_CONSTANT = 0,
IPL_BORDER_REPLICATE = 1,
IPL_BORDER_REFLECT = 2,
IPL_BORDER_WRAP = 3,
IPL_BORDER_REFLECT_101 = 4,
IPL_BORDER_TRANSPARENT = 5,
CV_INTER_NN = 0,
CV_INTER_LINEAR = 1,
CV_INTER_CUBIC = 2,
CV_INTER_AREA = 3,
CV_INTER_LANCZOS4 = 4,
CV_MOP_ERODE = 0,
CV_MOP_DILATE = 1,
CV_MOP_OPEN = 2,
CV_MOP_CLOSE = 3,
CV_MOP_GRADIENT = 4,
CV_MOP_TOPHAT = 5,
CV_MOP_BLACKHAT = 6,
CV_RETR_EXTERNAL = 0,
CV_RETR_LIST = 1,
CV_RETR_CCOMP = 2,
CV_RETR_TREE = 3,
CV_RETR_FLOODFILL = 4,
CV_CHAIN_APPROX_NONE = 1,
CV_CHAIN_APPROX_SIMPLE = 2,
CV_CHAIN_APPROX_TC89_L1 = 3,
CV_CHAIN_APPROX_TC89_KCOS = 4,
CV_THRESH_BINARY = 0,
CV_THRESH_BINARY_INV = 1,
CV_THRESH_TRUNC = 2,
CV_THRESH_TOZERO = 3,
CV_THRESH_TOZERO_INV = 4,
CV_THRESH_MASK = 7,
CV_THRESH_OTSU = 8,
CV_THRESH_TRIANGLE = 16;
public static final int
LINE_AA = 16,
LINE_8 = 8,
LINE_4 = 4,
CV_BLUR_NO_SCALE = 0,
CV_BLUR = 1,
CV_GAUSSIAN = 2,
CV_MEDIAN = 3,
CV_BILATERAL = 4,
CV_GAUSSIAN_5x5 = 7,
CV_SCHARR = -1,
CV_MAX_SOBEL_KSIZE = 7,
CV_RGBA2mRGBA = 125,
CV_mRGBA2RGBA = 126,
CV_WARP_FILL_OUTLIERS = 8,
CV_WARP_INVERSE_MAP = 16,
CV_SHAPE_RECT = 0,
CV_SHAPE_CROSS = 1,
CV_SHAPE_ELLIPSE = 2,
CV_SHAPE_CUSTOM = 100,
CV_CHAIN_CODE = 0,
CV_LINK_RUNS = 5,
CV_POLY_APPROX_DP = 0,
CV_CONTOURS_MATCH_I1 = 1,
CV_CONTOURS_MATCH_I2 = 2,
CV_CONTOURS_MATCH_I3 = 3,
CV_CLOCKWISE = 1,
CV_COUNTER_CLOCKWISE = 2,
CV_COMP_CORREL = 0,
CV_COMP_CHISQR = 1,
CV_COMP_INTERSECT = 2,
CV_COMP_BHATTACHARYYA = 3,
CV_COMP_HELLINGER = CV_COMP_BHATTACHARYYA,
CV_COMP_CHISQR_ALT = 4,
CV_COMP_KL_DIV = 5,
CV_DIST_MASK_3 = 3,
CV_DIST_MASK_5 = 5,
CV_DIST_MASK_PRECISE = 0,
CV_DIST_LABEL_CCOMP = 0,
CV_DIST_LABEL_PIXEL = 1,
CV_DIST_USER = -1,
CV_DIST_L1 = 1,
CV_DIST_L2 = 2,
CV_DIST_C = 3,
CV_DIST_L12 = 4,
CV_DIST_FAIR = 5,
CV_DIST_WELSCH = 6,
CV_DIST_HUBER = 7,
CV_CANNY_L2_GRADIENT = (1 << 31),
CV_HOUGH_STANDARD = 0,
CV_HOUGH_PROBABILISTIC = 1,
CV_HOUGH_MULTI_SCALE = 2,
CV_HOUGH_GRADIENT = 3,
MORPH_ERODE = 0,
MORPH_DILATE = 1,
MORPH_OPEN = 2,
MORPH_CLOSE = 3,
MORPH_GRADIENT = 4,
MORPH_TOPHAT = 5,
MORPH_BLACKHAT = 6,
MORPH_HITMISS = 7,
MORPH_RECT = 0,
MORPH_CROSS = 1,
MORPH_ELLIPSE = 2,
INTER_NEAREST = 0,
INTER_LINEAR = 1,
INTER_CUBIC = 2,
INTER_AREA = 3,
INTER_LANCZOS4 = 4,
INTER_MAX = 7,
WARP_FILL_OUTLIERS = 8,
WARP_INVERSE_MAP = 16,
INTER_BITS = 5,
INTER_BITS2 = INTER_BITS * 2,
INTER_TAB_SIZE = 1 << INTER_BITS,
INTER_TAB_SIZE2 = INTER_TAB_SIZE * INTER_TAB_SIZE,
DIST_USER = -1,
DIST_L1 = 1,
DIST_L2 = 2,
DIST_C = 3,
DIST_L12 = 4,
DIST_FAIR = 5,
DIST_WELSCH = 6,
DIST_HUBER = 7,
DIST_MASK_3 = 3,
DIST_MASK_5 = 5,
DIST_MASK_PRECISE = 0,
THRESH_BINARY = 0,
THRESH_BINARY_INV = 1,
THRESH_TRUNC = 2,
THRESH_TOZERO = 3,
THRESH_TOZERO_INV = 4,
THRESH_MASK = 7,
THRESH_OTSU = 8,
THRESH_TRIANGLE = 16,
ADAPTIVE_THRESH_MEAN_C = 0,
ADAPTIVE_THRESH_GAUSSIAN_C = 1,
PROJ_SPHERICAL_ORTHO = 0,
PROJ_SPHERICAL_EQRECT = 1,
GC_BGD = 0,
GC_FGD = 1,
GC_PR_BGD = 2,
GC_PR_FGD = 3,
GC_INIT_WITH_RECT = 0,
GC_INIT_WITH_MASK = 1,
GC_EVAL = 2,
DIST_LABEL_CCOMP = 0,
DIST_LABEL_PIXEL = 1,
FLOODFILL_FIXED_RANGE = 1 << 16,
FLOODFILL_MASK_ONLY = 1 << 17,
CC_STAT_LEFT = 0,
CC_STAT_TOP = 1,
CC_STAT_WIDTH = 2,
CC_STAT_HEIGHT = 3,
CC_STAT_AREA = 4,
CC_STAT_MAX = 5,
RETR_EXTERNAL = 0,
RETR_LIST = 1,
RETR_CCOMP = 2,
RETR_TREE = 3,
RETR_FLOODFILL = 4,
CHAIN_APPROX_NONE = 1,
CHAIN_APPROX_SIMPLE = 2,
CHAIN_APPROX_TC89_L1 = 3,
CHAIN_APPROX_TC89_KCOS = 4,
HOUGH_STANDARD = 0,
HOUGH_PROBABILISTIC = 1,
HOUGH_MULTI_SCALE = 2,
HOUGH_GRADIENT = 3,
LSD_REFINE_NONE = 0,
LSD_REFINE_STD = 1,
LSD_REFINE_ADV = 2,
HISTCMP_CORREL = 0,
HISTCMP_CHISQR = 1,
HISTCMP_INTERSECT = 2,
HISTCMP_BHATTACHARYYA = 3,
HISTCMP_HELLINGER = HISTCMP_BHATTACHARYYA,
HISTCMP_CHISQR_ALT = 4,
HISTCMP_KL_DIV = 5,
COLOR_BGR2BGRA = 0,
COLOR_RGB2RGBA = COLOR_BGR2BGRA,
COLOR_BGRA2BGR = 1,
COLOR_RGBA2RGB = COLOR_BGRA2BGR,
COLOR_BGR2RGBA = 2,
COLOR_RGB2BGRA = COLOR_BGR2RGBA,
COLOR_RGBA2BGR = 3,
COLOR_BGRA2RGB = COLOR_RGBA2BGR,
COLOR_BGR2RGB = 4,
COLOR_RGB2BGR = COLOR_BGR2RGB,
COLOR_BGRA2RGBA = 5,
COLOR_RGBA2BGRA = COLOR_BGRA2RGBA,
COLOR_BGR2GRAY = 6,
COLOR_RGB2GRAY = 7,
COLOR_GRAY2BGR = 8,
COLOR_GRAY2RGB = COLOR_GRAY2BGR,
COLOR_GRAY2BGRA = 9,
COLOR_GRAY2RGBA = COLOR_GRAY2BGRA,
COLOR_BGRA2GRAY = 10,
COLOR_RGBA2GRAY = 11,
COLOR_BGR2BGR565 = 12,
COLOR_RGB2BGR565 = 13,
COLOR_BGR5652BGR = 14,
COLOR_BGR5652RGB = 15,
COLOR_BGRA2BGR565 = 16,
COLOR_RGBA2BGR565 = 17,
COLOR_BGR5652BGRA = 18,
COLOR_BGR5652RGBA = 19,
COLOR_GRAY2BGR565 = 20,
COLOR_BGR5652GRAY = 21,
COLOR_BGR2BGR555 = 22,
COLOR_RGB2BGR555 = 23,
COLOR_BGR5552BGR = 24,
COLOR_BGR5552RGB = 25,
COLOR_BGRA2BGR555 = 26,
COLOR_RGBA2BGR555 = 27,
COLOR_BGR5552BGRA = 28,
COLOR_BGR5552RGBA = 29,
COLOR_GRAY2BGR555 = 30,
COLOR_BGR5552GRAY = 31,
COLOR_BGR2XYZ = 32,
COLOR_RGB2XYZ = 33,
COLOR_XYZ2BGR = 34,
COLOR_XYZ2RGB = 35,
COLOR_BGR2YCrCb = 36,
COLOR_RGB2YCrCb = 37,
COLOR_YCrCb2BGR = 38,
COLOR_YCrCb2RGB = 39,
COLOR_BGR2HSV = 40,
COLOR_RGB2HSV = 41,
COLOR_BGR2Lab = 44,
COLOR_RGB2Lab = 45,
COLOR_BGR2Luv = 50,
COLOR_RGB2Luv = 51,
COLOR_BGR2HLS = 52,
COLOR_RGB2HLS = 53,
COLOR_HSV2BGR = 54,
COLOR_HSV2RGB = 55,
COLOR_Lab2BGR = 56,
COLOR_Lab2RGB = 57,
COLOR_Luv2BGR = 58,
COLOR_Luv2RGB = 59,
COLOR_HLS2BGR = 60,
COLOR_HLS2RGB = 61,
COLOR_BGR2HSV_FULL = 66,
COLOR_RGB2HSV_FULL = 67,
COLOR_BGR2HLS_FULL = 68,
COLOR_RGB2HLS_FULL = 69,
COLOR_HSV2BGR_FULL = 70,
COLOR_HSV2RGB_FULL = 71,
COLOR_HLS2BGR_FULL = 72,
COLOR_HLS2RGB_FULL = 73,
COLOR_LBGR2Lab = 74,
COLOR_LRGB2Lab = 75,
COLOR_LBGR2Luv = 76,
COLOR_LRGB2Luv = 77,
COLOR_Lab2LBGR = 78,
COLOR_Lab2LRGB = 79,
COLOR_Luv2LBGR = 80,
COLOR_Luv2LRGB = 81,
COLOR_BGR2YUV = 82,
COLOR_RGB2YUV = 83,
COLOR_YUV2BGR = 84,
COLOR_YUV2RGB = 85,
COLOR_YUV2RGB_NV12 = 90,
COLOR_YUV2BGR_NV12 = 91,
COLOR_YUV2RGB_NV21 = 92,
COLOR_YUV2BGR_NV21 = 93,
COLOR_YUV420sp2RGB = COLOR_YUV2RGB_NV21,
COLOR_YUV420sp2BGR = COLOR_YUV2BGR_NV21,
COLOR_YUV2RGBA_NV12 = 94,
COLOR_YUV2BGRA_NV12 = 95,
COLOR_YUV2RGBA_NV21 = 96,
COLOR_YUV2BGRA_NV21 = 97,
COLOR_YUV420sp2RGBA = COLOR_YUV2RGBA_NV21,
COLOR_YUV420sp2BGRA = COLOR_YUV2BGRA_NV21,
COLOR_YUV2RGB_YV12 = 98,
COLOR_YUV2BGR_YV12 = 99,
COLOR_YUV2RGB_IYUV = 100,
COLOR_YUV2BGR_IYUV = 101,
COLOR_YUV2RGB_I420 = COLOR_YUV2RGB_IYUV,
COLOR_YUV2BGR_I420 = COLOR_YUV2BGR_IYUV,
COLOR_YUV420p2RGB = COLOR_YUV2RGB_YV12,
COLOR_YUV420p2BGR = COLOR_YUV2BGR_YV12,
COLOR_YUV2RGBA_YV12 = 102,
COLOR_YUV2BGRA_YV12 = 103,
COLOR_YUV2RGBA_IYUV = 104,
COLOR_YUV2BGRA_IYUV = 105,
COLOR_YUV2RGBA_I420 = COLOR_YUV2RGBA_IYUV,
COLOR_YUV2BGRA_I420 = COLOR_YUV2BGRA_IYUV,
COLOR_YUV420p2RGBA = COLOR_YUV2RGBA_YV12,
COLOR_YUV420p2BGRA = COLOR_YUV2BGRA_YV12,
COLOR_YUV2GRAY_420 = 106,
COLOR_YUV2GRAY_NV21 = COLOR_YUV2GRAY_420,
COLOR_YUV2GRAY_NV12 = COLOR_YUV2GRAY_420,
COLOR_YUV2GRAY_YV12 = COLOR_YUV2GRAY_420,
COLOR_YUV2GRAY_IYUV = COLOR_YUV2GRAY_420,
COLOR_YUV2GRAY_I420 = COLOR_YUV2GRAY_420,
COLOR_YUV420sp2GRAY = COLOR_YUV2GRAY_420,
COLOR_YUV420p2GRAY = COLOR_YUV2GRAY_420,
COLOR_YUV2RGB_UYVY = 107,
COLOR_YUV2BGR_UYVY = 108,
COLOR_YUV2RGB_Y422 = COLOR_YUV2RGB_UYVY,
COLOR_YUV2BGR_Y422 = COLOR_YUV2BGR_UYVY,
COLOR_YUV2RGB_UYNV = COLOR_YUV2RGB_UYVY,
COLOR_YUV2BGR_UYNV = COLOR_YUV2BGR_UYVY,
COLOR_YUV2RGBA_UYVY = 111,
COLOR_YUV2BGRA_UYVY = 112,
COLOR_YUV2RGBA_Y422 = COLOR_YUV2RGBA_UYVY,
COLOR_YUV2BGRA_Y422 = COLOR_YUV2BGRA_UYVY,
COLOR_YUV2RGBA_UYNV = COLOR_YUV2RGBA_UYVY,
COLOR_YUV2BGRA_UYNV = COLOR_YUV2BGRA_UYVY,
COLOR_YUV2RGB_YUY2 = 115,
COLOR_YUV2BGR_YUY2 = 116,
COLOR_YUV2RGB_YVYU = 117,
COLOR_YUV2BGR_YVYU = 118,
COLOR_YUV2RGB_YUYV = COLOR_YUV2RGB_YUY2,
COLOR_YUV2BGR_YUYV = COLOR_YUV2BGR_YUY2,
COLOR_YUV2RGB_YUNV = COLOR_YUV2RGB_YUY2,
COLOR_YUV2BGR_YUNV = COLOR_YUV2BGR_YUY2,
COLOR_YUV2RGBA_YUY2 = 119,
COLOR_YUV2BGRA_YUY2 = 120,
COLOR_YUV2RGBA_YVYU = 121,
COLOR_YUV2BGRA_YVYU = 122,
COLOR_YUV2RGBA_YUYV = COLOR_YUV2RGBA_YUY2,
COLOR_YUV2BGRA_YUYV = COLOR_YUV2BGRA_YUY2,
COLOR_YUV2RGBA_YUNV = COLOR_YUV2RGBA_YUY2,
COLOR_YUV2BGRA_YUNV = COLOR_YUV2BGRA_YUY2,
COLOR_YUV2GRAY_UYVY = 123,
COLOR_YUV2GRAY_YUY2 = 124,
COLOR_YUV2GRAY_Y422 = COLOR_YUV2GRAY_UYVY,
COLOR_YUV2GRAY_UYNV = COLOR_YUV2GRAY_UYVY,
COLOR_YUV2GRAY_YVYU = COLOR_YUV2GRAY_YUY2,
COLOR_YUV2GRAY_YUYV = COLOR_YUV2GRAY_YUY2,
COLOR_YUV2GRAY_YUNV = COLOR_YUV2GRAY_YUY2,
COLOR_RGBA2mRGBA = 125,
COLOR_mRGBA2RGBA = 126,
COLOR_RGB2YUV_I420 = 127,
COLOR_BGR2YUV_I420 = 128,
COLOR_RGB2YUV_IYUV = COLOR_RGB2YUV_I420,
COLOR_BGR2YUV_IYUV = COLOR_BGR2YUV_I420,
COLOR_RGBA2YUV_I420 = 129,
COLOR_BGRA2YUV_I420 = 130,
COLOR_RGBA2YUV_IYUV = COLOR_RGBA2YUV_I420,
COLOR_BGRA2YUV_IYUV = COLOR_BGRA2YUV_I420,
COLOR_RGB2YUV_YV12 = 131,
COLOR_BGR2YUV_YV12 = 132,
COLOR_RGBA2YUV_YV12 = 133,
COLOR_BGRA2YUV_YV12 = 134,
COLOR_BayerBG2BGR = 46,
COLOR_BayerGB2BGR = 47,
COLOR_BayerRG2BGR = 48,
COLOR_BayerGR2BGR = 49,
COLOR_BayerBG2RGB = COLOR_BayerRG2BGR,
COLOR_BayerGB2RGB = COLOR_BayerGR2BGR,
COLOR_BayerRG2RGB = COLOR_BayerBG2BGR,
COLOR_BayerGR2RGB = COLOR_BayerGB2BGR,
COLOR_BayerBG2GRAY = 86,
COLOR_BayerGB2GRAY = 87,
COLOR_BayerRG2GRAY = 88,
COLOR_BayerGR2GRAY = 89,
COLOR_BayerBG2BGR_VNG = 62,
COLOR_BayerGB2BGR_VNG = 63,
COLOR_BayerRG2BGR_VNG = 64,
COLOR_BayerGR2BGR_VNG = 65,
COLOR_BayerBG2RGB_VNG = COLOR_BayerRG2BGR_VNG,
COLOR_BayerGB2RGB_VNG = COLOR_BayerGR2BGR_VNG,
COLOR_BayerRG2RGB_VNG = COLOR_BayerBG2BGR_VNG,
COLOR_BayerGR2RGB_VNG = COLOR_BayerGB2BGR_VNG,
COLOR_BayerBG2BGR_EA = 135,
COLOR_BayerGB2BGR_EA = 136,
COLOR_BayerRG2BGR_EA = 137,
COLOR_BayerGR2BGR_EA = 138,
COLOR_BayerBG2RGB_EA = COLOR_BayerRG2BGR_EA,
COLOR_BayerGB2RGB_EA = COLOR_BayerGR2BGR_EA,
COLOR_BayerRG2RGB_EA = COLOR_BayerBG2BGR_EA,
COLOR_BayerGR2RGB_EA = COLOR_BayerGB2BGR_EA,
COLOR_COLORCVT_MAX = 139,
INTERSECT_NONE = 0,
INTERSECT_PARTIAL = 1,
INTERSECT_FULL = 2,
TM_SQDIFF = 0,
TM_SQDIFF_NORMED = 1,
TM_CCORR = 2,
TM_CCORR_NORMED = 3,
TM_CCOEFF = 4,
TM_CCOEFF_NORMED = 5,
COLORMAP_AUTUMN = 0,
COLORMAP_BONE = 1,
COLORMAP_JET = 2,
COLORMAP_WINTER = 3,
COLORMAP_RAINBOW = 4,
COLORMAP_OCEAN = 5,
COLORMAP_SUMMER = 6,
COLORMAP_SPRING = 7,
COLORMAP_COOL = 8,
COLORMAP_HSV = 9,
COLORMAP_PINK = 10,
COLORMAP_HOT = 11,
COLORMAP_PARULA = 12,
MARKER_CROSS = 0,
MARKER_TILTED_CROSS = 1,
MARKER_STAR = 2,
MARKER_DIAMOND = 3,
MARKER_SQUARE = 4,
MARKER_TRIANGLE_UP = 5,
MARKER_TRIANGLE_DOWN = 6;
//
// C++: Mat getAffineTransform(vector_Point2f src, vector_Point2f dst)
//
//javadoc: getAffineTransform(src, dst)
public static Mat getAffineTransform(MatOfPoint2f src, MatOfPoint2f dst)
{
Mat src_mat = src;
Mat dst_mat = dst;
Mat retVal = new Mat(getAffineTransform_0(src_mat.nativeObj, dst_mat.nativeObj));
return retVal;
}
//
// C++: Mat getDefaultNewCameraMatrix(Mat cameraMatrix, Size imgsize = Size(), bool centerPrincipalPoint = false)
//
//javadoc: getDefaultNewCameraMatrix(cameraMatrix, imgsize, centerPrincipalPoint)
public static Mat getDefaultNewCameraMatrix(Mat cameraMatrix, Size imgsize, boolean centerPrincipalPoint)
{
Mat retVal = new Mat(getDefaultNewCameraMatrix_0(cameraMatrix.nativeObj, imgsize.width, imgsize.height, centerPrincipalPoint));
return retVal;
}
//javadoc: getDefaultNewCameraMatrix(cameraMatrix)
public static Mat getDefaultNewCameraMatrix(Mat cameraMatrix)
{
Mat retVal = new Mat(getDefaultNewCameraMatrix_1(cameraMatrix.nativeObj));
return retVal;
}
//
// C++: Mat getGaborKernel(Size ksize, double sigma, double theta, double lambd, double gamma, double psi = CV_PI*0.5, int ktype = CV_64F)
//
//javadoc: getGaborKernel(ksize, sigma, theta, lambd, gamma, psi, ktype)
public static Mat getGaborKernel(Size ksize, double sigma, double theta, double lambd, double gamma, double psi, int ktype)
{
Mat retVal = new Mat(getGaborKernel_0(ksize.width, ksize.height, sigma, theta, lambd, gamma, psi, ktype));
return retVal;
}
//javadoc: getGaborKernel(ksize, sigma, theta, lambd, gamma)
public static Mat getGaborKernel(Size ksize, double sigma, double theta, double lambd, double gamma)
{
Mat retVal = new Mat(getGaborKernel_1(ksize.width, ksize.height, sigma, theta, lambd, gamma));
return retVal;
}
//
// C++: Mat getGaussianKernel(int ksize, double sigma, int ktype = CV_64F)
//
//javadoc: getGaussianKernel(ksize, sigma, ktype)
public static Mat getGaussianKernel(int ksize, double sigma, int ktype)
{
Mat retVal = new Mat(getGaussianKernel_0(ksize, sigma, ktype));
return retVal;
}
//javadoc: getGaussianKernel(ksize, sigma)
public static Mat getGaussianKernel(int ksize, double sigma)
{
Mat retVal = new Mat(getGaussianKernel_1(ksize, sigma));
return retVal;
}
//
// C++: Mat getPerspectiveTransform(Mat src, Mat dst)
//
//javadoc: getPerspectiveTransform(src, dst)
public static Mat getPerspectiveTransform(Mat src, Mat dst)
{
Mat retVal = new Mat(getPerspectiveTransform_0(src.nativeObj, dst.nativeObj));
return retVal;
}
//
// C++: Mat getRotationMatrix2D(Point2f center, double angle, double scale)
//
//javadoc: getRotationMatrix2D(center, angle, scale)
public static Mat getRotationMatrix2D(Point center, double angle, double scale)
{
Mat retVal = new Mat(getRotationMatrix2D_0(center.x, center.y, angle, scale));
return retVal;
}
//
// C++: Mat getStructuringElement(int shape, Size ksize, Point anchor = Point(-1,-1))
//
//javadoc: getStructuringElement(shape, ksize, anchor)
public static Mat getStructuringElement(int shape, Size ksize, Point anchor)
{
Mat retVal = new Mat(getStructuringElement_0(shape, ksize.width, ksize.height, anchor.x, anchor.y));
return retVal;
}
//javadoc: getStructuringElement(shape, ksize)
public static Mat getStructuringElement(int shape, Size ksize)
{
Mat retVal = new Mat(getStructuringElement_1(shape, ksize.width, ksize.height));
return retVal;
}
//
// C++: Moments moments(Mat array, bool binaryImage = false)
//
//javadoc: moments(array, binaryImage)
public static Moments moments(Mat array, boolean binaryImage)
{
Moments retVal = new Moments(moments_0(array.nativeObj, binaryImage));
return retVal;
}
//javadoc: moments(array)
public static Moments moments(Mat array)
{
Moments retVal = new Moments(moments_1(array.nativeObj));
return retVal;
}
//
// C++: Point2d phaseCorrelate(Mat src1, Mat src2, Mat window = Mat(), double* response = 0)
//
//javadoc: phaseCorrelate(src1, src2, window, response)
public static Point phaseCorrelate(Mat src1, Mat src2, Mat window, double[] response)
{
double[] response_out = new double[1];
Point retVal = new Point(phaseCorrelate_0(src1.nativeObj, src2.nativeObj, window.nativeObj, response_out));
if(response!=null) response[0] = (double)response_out[0];
return retVal;
}
//javadoc: phaseCorrelate(src1, src2)
public static Point phaseCorrelate(Mat src1, Mat src2)
{
Point retVal = new Point(phaseCorrelate_1(src1.nativeObj, src2.nativeObj));
return retVal;
}
//
// C++: Ptr_CLAHE createCLAHE(double clipLimit = 40.0, Size tileGridSize = Size(8, 8))
//
//javadoc: createCLAHE(clipLimit, tileGridSize)
public static CLAHE createCLAHE(double clipLimit, Size tileGridSize)
{
CLAHE retVal = new CLAHE(createCLAHE_0(clipLimit, tileGridSize.width, tileGridSize.height));
return retVal;
}
//javadoc: createCLAHE()
public static CLAHE createCLAHE()
{
CLAHE retVal = new CLAHE(createCLAHE_1());
return retVal;
}
//
// C++: Ptr_LineSegmentDetector createLineSegmentDetector(int _refine = LSD_REFINE_STD, double _scale = 0.8, double _sigma_scale = 0.6, double _quant = 2.0, double _ang_th = 22.5, double _log_eps = 0, double _density_th = 0.7, int _n_bins = 1024)
//
//javadoc: createLineSegmentDetector(_refine, _scale, _sigma_scale, _quant, _ang_th, _log_eps, _density_th, _n_bins)
public static LineSegmentDetector createLineSegmentDetector(int _refine, double _scale, double _sigma_scale, double _quant, double _ang_th, double _log_eps, double _density_th, int _n_bins)
{
LineSegmentDetector retVal = new LineSegmentDetector(createLineSegmentDetector_0(_refine, _scale, _sigma_scale, _quant, _ang_th, _log_eps, _density_th, _n_bins));
return retVal;
}
//javadoc: createLineSegmentDetector()
public static LineSegmentDetector createLineSegmentDetector()
{
LineSegmentDetector retVal = new LineSegmentDetector(createLineSegmentDetector_1());
return retVal;
}
//
// C++: Rect boundingRect(vector_Point points)
//
//javadoc: boundingRect(points)
public static Rect boundingRect(MatOfPoint points)
{
Mat points_mat = points;
Rect retVal = new Rect(boundingRect_0(points_mat.nativeObj));
return retVal;
}
//
// C++: RotatedRect fitEllipse(vector_Point2f points)
//
//javadoc: fitEllipse(points)
public static RotatedRect fitEllipse(MatOfPoint2f points)
{
Mat points_mat = points;
RotatedRect retVal = new RotatedRect(fitEllipse_0(points_mat.nativeObj));
return retVal;
}
//
// C++: RotatedRect minAreaRect(vector_Point2f points)
//
//javadoc: minAreaRect(points)
public static RotatedRect minAreaRect(MatOfPoint2f points)
{
Mat points_mat = points;
RotatedRect retVal = new RotatedRect(minAreaRect_0(points_mat.nativeObj));
return retVal;
}
//
// C++: bool clipLine(Rect imgRect, Point& pt1, Point& pt2)
//
//javadoc: clipLine(imgRect, pt1, pt2)
public static boolean clipLine(Rect imgRect, Point pt1, Point pt2)
{
double[] pt1_out = new double[2];
double[] pt2_out = new double[2];
boolean retVal = clipLine_0(imgRect.x, imgRect.y, imgRect.width, imgRect.height, pt1.x, pt1.y, pt1_out, pt2.x, pt2.y, pt2_out);
if(pt1!=null){ pt1.x = pt1_out[0]; pt1.y = pt1_out[1]; }
if(pt2!=null){ pt2.x = pt2_out[0]; pt2.y = pt2_out[1]; }
return retVal;
}
//
// C++: bool isContourConvex(vector_Point contour)
//
//javadoc: isContourConvex(contour)
public static boolean isContourConvex(MatOfPoint contour)
{
Mat contour_mat = contour;
boolean retVal = isContourConvex_0(contour_mat.nativeObj);
return retVal;
}
//
// C++: double arcLength(vector_Point2f curve, bool closed)
//
//javadoc: arcLength(curve, closed)
public static double arcLength(MatOfPoint2f curve, boolean closed)
{
Mat curve_mat = curve;
double retVal = arcLength_0(curve_mat.nativeObj, closed);
return retVal;
}
//
// C++: double compareHist(Mat H1, Mat H2, int method)
//
//javadoc: compareHist(H1, H2, method)
public static double compareHist(Mat H1, Mat H2, int method)
{
double retVal = compareHist_0(H1.nativeObj, H2.nativeObj, method);
return retVal;
}
//
// C++: double contourArea(Mat contour, bool oriented = false)
//
//javadoc: contourArea(contour, oriented)
public static double contourArea(Mat contour, boolean oriented)
{
double retVal = contourArea_0(contour.nativeObj, oriented);
return retVal;
}
//javadoc: contourArea(contour)
public static double contourArea(Mat contour)
{
double retVal = contourArea_1(contour.nativeObj);
return retVal;
}
//
// C++: double matchShapes(Mat contour1, Mat contour2, int method, double parameter)
//
//javadoc: matchShapes(contour1, contour2, method, parameter)
public static double matchShapes(Mat contour1, Mat contour2, int method, double parameter)
{
double retVal = matchShapes_0(contour1.nativeObj, contour2.nativeObj, method, parameter);
return retVal;
}
//
// C++: double minEnclosingTriangle(Mat points, Mat& triangle)
//
//javadoc: minEnclosingTriangle(points, triangle)
public static double minEnclosingTriangle(Mat points, Mat triangle)
{
double retVal = minEnclosingTriangle_0(points.nativeObj, triangle.nativeObj);
return retVal;
}
//
// C++: double pointPolygonTest(vector_Point2f contour, Point2f pt, bool measureDist)
//
//javadoc: pointPolygonTest(contour, pt, measureDist)
public static double pointPolygonTest(MatOfPoint2f contour, Point pt, boolean measureDist)
{
Mat contour_mat = contour;
double retVal = pointPolygonTest_0(contour_mat.nativeObj, pt.x, pt.y, measureDist);
return retVal;
}
//
// C++: double threshold(Mat src, Mat& dst, double thresh, double maxval, int type)
//
//javadoc: threshold(src, dst, thresh, maxval, type)
public static double threshold(Mat src, Mat dst, double thresh, double maxval, int type)
{
double retVal = threshold_0(src.nativeObj, dst.nativeObj, thresh, maxval, type);
return retVal;
}
//
// C++: float initWideAngleProjMap(Mat cameraMatrix, Mat distCoeffs, Size imageSize, int destImageWidth, int m1type, Mat& map1, Mat& map2, int projType = PROJ_SPHERICAL_EQRECT, double alpha = 0)
//
//javadoc: initWideAngleProjMap(cameraMatrix, distCoeffs, imageSize, destImageWidth, m1type, map1, map2, projType, alpha)
public static float initWideAngleProjMap(Mat cameraMatrix, Mat distCoeffs, Size imageSize, int destImageWidth, int m1type, Mat map1, Mat map2, int projType, double alpha)
{
float retVal = initWideAngleProjMap_0(cameraMatrix.nativeObj, distCoeffs.nativeObj, imageSize.width, imageSize.height, destImageWidth, m1type, map1.nativeObj, map2.nativeObj, projType, alpha);
return retVal;
}
//javadoc: initWideAngleProjMap(cameraMatrix, distCoeffs, imageSize, destImageWidth, m1type, map1, map2)
public static float initWideAngleProjMap(Mat cameraMatrix, Mat distCoeffs, Size imageSize, int destImageWidth, int m1type, Mat map1, Mat map2)
{
float retVal = initWideAngleProjMap_1(cameraMatrix.nativeObj, distCoeffs.nativeObj, imageSize.width, imageSize.height, destImageWidth, m1type, map1.nativeObj, map2.nativeObj);
return retVal;
}
//
// C++: float intersectConvexConvex(Mat _p1, Mat _p2, Mat& _p12, bool handleNested = true)
//
//javadoc: intersectConvexConvex(_p1, _p2, _p12, handleNested)
public static float intersectConvexConvex(Mat _p1, Mat _p2, Mat _p12, boolean handleNested)
{
float retVal = intersectConvexConvex_0(_p1.nativeObj, _p2.nativeObj, _p12.nativeObj, handleNested);
return retVal;
}
//javadoc: intersectConvexConvex(_p1, _p2, _p12)
public static float intersectConvexConvex(Mat _p1, Mat _p2, Mat _p12)
{
float retVal = intersectConvexConvex_1(_p1.nativeObj, _p2.nativeObj, _p12.nativeObj);
return retVal;
}
//
// C++: int connectedComponents(Mat image, Mat& labels, int connectivity = 8, int ltype = CV_32S)
//
//javadoc: connectedComponents(image, labels, connectivity, ltype)
public static int connectedComponents(Mat image, Mat labels, int connectivity, int ltype)
{
int retVal = connectedComponents_0(image.nativeObj, labels.nativeObj, connectivity, ltype);
return retVal;
}
//javadoc: connectedComponents(image, labels)
public static int connectedComponents(Mat image, Mat labels)
{
int retVal = connectedComponents_1(image.nativeObj, labels.nativeObj);
return retVal;
}
//
// C++: int connectedComponentsWithStats(Mat image, Mat& labels, Mat& stats, Mat& centroids, int connectivity = 8, int ltype = CV_32S)
//
//javadoc: connectedComponentsWithStats(image, labels, stats, centroids, connectivity, ltype)
public static int connectedComponentsWithStats(Mat image, Mat labels, Mat stats, Mat centroids, int connectivity, int ltype)
{
int retVal = connectedComponentsWithStats_0(image.nativeObj, labels.nativeObj, stats.nativeObj, centroids.nativeObj, connectivity, ltype);
return retVal;
}
//javadoc: connectedComponentsWithStats(image, labels, stats, centroids)
public static int connectedComponentsWithStats(Mat image, Mat labels, Mat stats, Mat centroids)
{
int retVal = connectedComponentsWithStats_1(image.nativeObj, labels.nativeObj, stats.nativeObj, centroids.nativeObj);
return retVal;
}
//
// C++: int floodFill(Mat& image, Mat& mask, Point seedPoint, Scalar newVal, Rect* rect = 0, Scalar loDiff = Scalar(), Scalar upDiff = Scalar(), int flags = 4)
//
//javadoc: floodFill(image, mask, seedPoint, newVal, rect, loDiff, upDiff, flags)
public static int floodFill(Mat image, Mat mask, Point seedPoint, Scalar newVal, Rect rect, Scalar loDiff, Scalar upDiff, int flags)
{
double[] rect_out = new double[4];
int retVal = floodFill_0(image.nativeObj, mask.nativeObj, seedPoint.x, seedPoint.y, newVal.val[0], newVal.val[1], newVal.val[2], newVal.val[3], rect_out, loDiff.val[0], loDiff.val[1], loDiff.val[2], loDiff.val[3], upDiff.val[0], upDiff.val[1], upDiff.val[2], upDiff.val[3], flags);
if(rect!=null){ rect.x = (int)rect_out[0]; rect.y = (int)rect_out[1]; rect.width = (int)rect_out[2]; rect.height = (int)rect_out[3]; }
return retVal;
}
//javadoc: floodFill(image, mask, seedPoint, newVal)
public static int floodFill(Mat image, Mat mask, Point seedPoint, Scalar newVal)
{
int retVal = floodFill_1(image.nativeObj, mask.nativeObj, seedPoint.x, seedPoint.y, newVal.val[0], newVal.val[1], newVal.val[2], newVal.val[3]);
return retVal;
}
//
// C++: int rotatedRectangleIntersection(RotatedRect rect1, RotatedRect rect2, Mat& intersectingRegion)
//
//javadoc: rotatedRectangleIntersection(rect1, rect2, intersectingRegion)
public static int rotatedRectangleIntersection(RotatedRect rect1, RotatedRect rect2, Mat intersectingRegion)
{
int retVal = rotatedRectangleIntersection_0(rect1.center.x, rect1.center.y, rect1.size.width, rect1.size.height, rect1.angle, rect2.center.x, rect2.center.y, rect2.size.width, rect2.size.height, rect2.angle, intersectingRegion.nativeObj);
return retVal;
}
//
// C++: void Canny(Mat image, Mat& edges, double threshold1, double threshold2, int apertureSize = 3, bool L2gradient = false)
//
//javadoc: Canny(image, edges, threshold1, threshold2, apertureSize, L2gradient)
public static void Canny(Mat image, Mat edges, double threshold1, double threshold2, int apertureSize, boolean L2gradient)
{
Canny_0(image.nativeObj, edges.nativeObj, threshold1, threshold2, apertureSize, L2gradient);
return;
}
//javadoc: Canny(image, edges, threshold1, threshold2)
public static void Canny(Mat image, Mat edges, double threshold1, double threshold2)
{
Canny_1(image.nativeObj, edges.nativeObj, threshold1, threshold2);
return;
}
//
// C++: void GaussianBlur(Mat src, Mat& dst, Size ksize, double sigmaX, double sigmaY = 0, int borderType = BORDER_DEFAULT)
//
//javadoc: GaussianBlur(src, dst, ksize, sigmaX, sigmaY, borderType)
public static void GaussianBlur(Mat src, Mat dst, Size ksize, double sigmaX, double sigmaY, int borderType)
{
GaussianBlur_0(src.nativeObj, dst.nativeObj, ksize.width, ksize.height, sigmaX, sigmaY, borderType);
return;
}
//javadoc: GaussianBlur(src, dst, ksize, sigmaX, sigmaY)
public static void GaussianBlur(Mat src, Mat dst, Size ksize, double sigmaX, double sigmaY)
{
GaussianBlur_1(src.nativeObj, dst.nativeObj, ksize.width, ksize.height, sigmaX, sigmaY);
return;
}
//javadoc: GaussianBlur(src, dst, ksize, sigmaX)
public static void GaussianBlur(Mat src, Mat dst, Size ksize, double sigmaX)
{
GaussianBlur_2(src.nativeObj, dst.nativeObj, ksize.width, ksize.height, sigmaX);
return;
}
//
// C++: void HoughCircles(Mat image, Mat& circles, int method, double dp, double minDist, double param1 = 100, double param2 = 100, int minRadius = 0, int maxRadius = 0)
//
//javadoc: HoughCircles(image, circles, method, dp, minDist, param1, param2, minRadius, maxRadius)
public static void HoughCircles(Mat image, Mat circles, int method, double dp, double minDist, double param1, double param2, int minRadius, int maxRadius)
{
HoughCircles_0(image.nativeObj, circles.nativeObj, method, dp, minDist, param1, param2, minRadius, maxRadius);
return;
}
//javadoc: HoughCircles(image, circles, method, dp, minDist)
public static void HoughCircles(Mat image, Mat circles, int method, double dp, double minDist)
{
HoughCircles_1(image.nativeObj, circles.nativeObj, method, dp, minDist);
return;
}
//
// C++: void HoughLines(Mat image, Mat& lines, double rho, double theta, int threshold, double srn = 0, double stn = 0, double min_theta = 0, double max_theta = CV_PI)
//
//javadoc: HoughLines(image, lines, rho, theta, threshold, srn, stn, min_theta, max_theta)
public static void HoughLines(Mat image, Mat lines, double rho, double theta, int threshold, double srn, double stn, double min_theta, double max_theta)
{
HoughLines_0(image.nativeObj, lines.nativeObj, rho, theta, threshold, srn, stn, min_theta, max_theta);
return;
}
//javadoc: HoughLines(image, lines, rho, theta, threshold)
public static void HoughLines(Mat image, Mat lines, double rho, double theta, int threshold)
{
HoughLines_1(image.nativeObj, lines.nativeObj, rho, theta, threshold);
return;
}
//
// C++: void HoughLinesP(Mat image, Mat& lines, double rho, double theta, int threshold, double minLineLength = 0, double maxLineGap = 0)
//
//javadoc: HoughLinesP(image, lines, rho, theta, threshold, minLineLength, maxLineGap)
public static void HoughLinesP(Mat image, Mat lines, double rho, double theta, int threshold, double minLineLength, double maxLineGap)
{
HoughLinesP_0(image.nativeObj, lines.nativeObj, rho, theta, threshold, minLineLength, maxLineGap);
return;
}
//javadoc: HoughLinesP(image, lines, rho, theta, threshold)
public static void HoughLinesP(Mat image, Mat lines, double rho, double theta, int threshold)
{
HoughLinesP_1(image.nativeObj, lines.nativeObj, rho, theta, threshold);
return;
}
//
// C++: void HuMoments(Moments m, Mat& hu)
//
//javadoc: HuMoments(m, hu)
public static void HuMoments(Moments m, Mat hu)
{
HuMoments_0(m.m00, m.m10, m.m01, m.m20, m.m11, m.m02, m.m30, m.m21, m.m12, m.m03, hu.nativeObj);
return;
}
//
// C++: void Laplacian(Mat src, Mat& dst, int ddepth, int ksize = 1, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT)
//
//javadoc: Laplacian(src, dst, ddepth, ksize, scale, delta, borderType)
public static void Laplacian(Mat src, Mat dst, int ddepth, int ksize, double scale, double delta, int borderType)
{
Laplacian_0(src.nativeObj, dst.nativeObj, ddepth, ksize, scale, delta, borderType);
return;
}
//javadoc: Laplacian(src, dst, ddepth, ksize, scale, delta)
public static void Laplacian(Mat src, Mat dst, int ddepth, int ksize, double scale, double delta)
{
Laplacian_1(src.nativeObj, dst.nativeObj, ddepth, ksize, scale, delta);
return;
}
//javadoc: Laplacian(src, dst, ddepth)
public static void Laplacian(Mat src, Mat dst, int ddepth)
{
Laplacian_2(src.nativeObj, dst.nativeObj, ddepth);
return;
}
//
// C++: void Scharr(Mat src, Mat& dst, int ddepth, int dx, int dy, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT)
//
//javadoc: Scharr(src, dst, ddepth, dx, dy, scale, delta, borderType)
public static void Scharr(Mat src, Mat dst, int ddepth, int dx, int dy, double scale, double delta, int borderType)
{
Scharr_0(src.nativeObj, dst.nativeObj, ddepth, dx, dy, scale, delta, borderType);
return;
}
//javadoc: Scharr(src, dst, ddepth, dx, dy, scale, delta)
public static void Scharr(Mat src, Mat dst, int ddepth, int dx, int dy, double scale, double delta)
{
Scharr_1(src.nativeObj, dst.nativeObj, ddepth, dx, dy, scale, delta);
return;
}
//javadoc: Scharr(src, dst, ddepth, dx, dy)
public static void Scharr(Mat src, Mat dst, int ddepth, int dx, int dy)
{
Scharr_2(src.nativeObj, dst.nativeObj, ddepth, dx, dy);
return;
}
//
// C++: void Sobel(Mat src, Mat& dst, int ddepth, int dx, int dy, int ksize = 3, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT)
//
//javadoc: Sobel(src, dst, ddepth, dx, dy, ksize, scale, delta, borderType)
public static void Sobel(Mat src, Mat dst, int ddepth, int dx, int dy, int ksize, double scale, double delta, int borderType)
{
Sobel_0(src.nativeObj, dst.nativeObj, ddepth, dx, dy, ksize, scale, delta, borderType);
return;
}
//javadoc: Sobel(src, dst, ddepth, dx, dy, ksize, scale, delta)
public static void Sobel(Mat src, Mat dst, int ddepth, int dx, int dy, int ksize, double scale, double delta)
{
Sobel_1(src.nativeObj, dst.nativeObj, ddepth, dx, dy, ksize, scale, delta);
return;
}
//javadoc: Sobel(src, dst, ddepth, dx, dy)
public static void Sobel(Mat src, Mat dst, int ddepth, int dx, int dy)
{
Sobel_2(src.nativeObj, dst.nativeObj, ddepth, dx, dy);
return;
}
//
// C++: void accumulate(Mat src, Mat& dst, Mat mask = Mat())
//
//javadoc: accumulate(src, dst, mask)
public static void accumulate(Mat src, Mat dst, Mat mask)
{
accumulate_0(src.nativeObj, dst.nativeObj, mask.nativeObj);
return;
}
//javadoc: accumulate(src, dst)
public static void accumulate(Mat src, Mat dst)
{
accumulate_1(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void accumulateProduct(Mat src1, Mat src2, Mat& dst, Mat mask = Mat())
//
//javadoc: accumulateProduct(src1, src2, dst, mask)
public static void accumulateProduct(Mat src1, Mat src2, Mat dst, Mat mask)
{
accumulateProduct_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj);
return;
}
//javadoc: accumulateProduct(src1, src2, dst)
public static void accumulateProduct(Mat src1, Mat src2, Mat dst)
{
accumulateProduct_1(src1.nativeObj, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void accumulateSquare(Mat src, Mat& dst, Mat mask = Mat())
//
//javadoc: accumulateSquare(src, dst, mask)
public static void accumulateSquare(Mat src, Mat dst, Mat mask)
{
accumulateSquare_0(src.nativeObj, dst.nativeObj, mask.nativeObj);
return;
}
//javadoc: accumulateSquare(src, dst)
public static void accumulateSquare(Mat src, Mat dst)
{
accumulateSquare_1(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void accumulateWeighted(Mat src, Mat& dst, double alpha, Mat mask = Mat())
//
//javadoc: accumulateWeighted(src, dst, alpha, mask)
public static void accumulateWeighted(Mat src, Mat dst, double alpha, Mat mask)
{
accumulateWeighted_0(src.nativeObj, dst.nativeObj, alpha, mask.nativeObj);
return;
}
//javadoc: accumulateWeighted(src, dst, alpha)
public static void accumulateWeighted(Mat src, Mat dst, double alpha)
{
accumulateWeighted_1(src.nativeObj, dst.nativeObj, alpha);
return;
}
//
// C++: void adaptiveThreshold(Mat src, Mat& dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C)
//
//javadoc: adaptiveThreshold(src, dst, maxValue, adaptiveMethod, thresholdType, blockSize, C)
public static void adaptiveThreshold(Mat src, Mat dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C)
{
adaptiveThreshold_0(src.nativeObj, dst.nativeObj, maxValue, adaptiveMethod, thresholdType, blockSize, C);
return;
}
//
// C++: void applyColorMap(Mat src, Mat& dst, int colormap)
//
//javadoc: applyColorMap(src, dst, colormap)
public static void applyColorMap(Mat src, Mat dst, int colormap)
{
applyColorMap_0(src.nativeObj, dst.nativeObj, colormap);
return;
}
//
// C++: void approxPolyDP(vector_Point2f curve, vector_Point2f& approxCurve, double epsilon, bool closed)
//
//javadoc: approxPolyDP(curve, approxCurve, epsilon, closed)
public static void approxPolyDP(MatOfPoint2f curve, MatOfPoint2f approxCurve, double epsilon, boolean closed)
{
Mat curve_mat = curve;
Mat approxCurve_mat = approxCurve;
approxPolyDP_0(curve_mat.nativeObj, approxCurve_mat.nativeObj, epsilon, closed);
return;
}
//
// C++: void arrowedLine(Mat& img, Point pt1, Point pt2, Scalar color, int thickness = 1, int line_type = 8, int shift = 0, double tipLength = 0.1)
//
//javadoc: arrowedLine(img, pt1, pt2, color, thickness, line_type, shift, tipLength)
public static void arrowedLine(Mat img, Point pt1, Point pt2, Scalar color, int thickness, int line_type, int shift, double tipLength)
{
arrowedLine_0(img.nativeObj, pt1.x, pt1.y, pt2.x, pt2.y, color.val[0], color.val[1], color.val[2], color.val[3], thickness, line_type, shift, tipLength);
return;
}
//javadoc: arrowedLine(img, pt1, pt2, color)
public static void arrowedLine(Mat img, Point pt1, Point pt2, Scalar color)
{
arrowedLine_1(img.nativeObj, pt1.x, pt1.y, pt2.x, pt2.y, color.val[0], color.val[1], color.val[2], color.val[3]);
return;
}
//
// C++: void bilateralFilter(Mat src, Mat& dst, int d, double sigmaColor, double sigmaSpace, int borderType = BORDER_DEFAULT)
//
//javadoc: bilateralFilter(src, dst, d, sigmaColor, sigmaSpace, borderType)
public static void bilateralFilter(Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace, int borderType)
{
bilateralFilter_0(src.nativeObj, dst.nativeObj, d, sigmaColor, sigmaSpace, borderType);
return;
}
//javadoc: bilateralFilter(src, dst, d, sigmaColor, sigmaSpace)
public static void bilateralFilter(Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace)
{
bilateralFilter_1(src.nativeObj, dst.nativeObj, d, sigmaColor, sigmaSpace);
return;
}
//
// C++: void blur(Mat src, Mat& dst, Size ksize, Point anchor = Point(-1,-1), int borderType = BORDER_DEFAULT)
//
//javadoc: blur(src, dst, ksize, anchor, borderType)
public static void blur(Mat src, Mat dst, Size ksize, Point anchor, int borderType)
{
blur_0(src.nativeObj, dst.nativeObj, ksize.width, ksize.height, anchor.x, anchor.y, borderType);
return;
}
//javadoc: blur(src, dst, ksize, anchor)
public static void blur(Mat src, Mat dst, Size ksize, Point anchor)
{
blur_1(src.nativeObj, dst.nativeObj, ksize.width, ksize.height, anchor.x, anchor.y);
return;
}
//javadoc: blur(src, dst, ksize)
public static void blur(Mat src, Mat dst, Size ksize)
{
blur_2(src.nativeObj, dst.nativeObj, ksize.width, ksize.height);
return;
}
//
// C++: void boxFilter(Mat src, Mat& dst, int ddepth, Size ksize, Point anchor = Point(-1,-1), bool normalize = true, int borderType = BORDER_DEFAULT)
//
//javadoc: boxFilter(src, dst, ddepth, ksize, anchor, normalize, borderType)
public static void boxFilter(Mat src, Mat dst, int ddepth, Size ksize, Point anchor, boolean normalize, int borderType)
{
boxFilter_0(src.nativeObj, dst.nativeObj, ddepth, ksize.width, ksize.height, anchor.x, anchor.y, normalize, borderType);
return;
}
//javadoc: boxFilter(src, dst, ddepth, ksize, anchor, normalize)
public static void boxFilter(Mat src, Mat dst, int ddepth, Size ksize, Point anchor, boolean normalize)
{
boxFilter_1(src.nativeObj, dst.nativeObj, ddepth, ksize.width, ksize.height, anchor.x, anchor.y, normalize);
return;
}
//javadoc: boxFilter(src, dst, ddepth, ksize)
public static void boxFilter(Mat src, Mat dst, int ddepth, Size ksize)
{
boxFilter_2(src.nativeObj, dst.nativeObj, ddepth, ksize.width, ksize.height);
return;
}
//
// C++: void boxPoints(RotatedRect box, Mat& points)
//
//javadoc: boxPoints(box, points)
public static void boxPoints(RotatedRect box, Mat points)
{
boxPoints_0(box.center.x, box.center.y, box.size.width, box.size.height, box.angle, points.nativeObj);
return;
}
//
// C++: void calcBackProject(vector_Mat images, vector_int channels, Mat hist, Mat& dst, vector_float ranges, double scale)
//
//javadoc: calcBackProject(images, channels, hist, dst, ranges, scale)
public static void calcBackProject(List<Mat> images, MatOfInt channels, Mat hist, Mat dst, MatOfFloat ranges, double scale)
{
Mat images_mat = Converters.vector_Mat_to_Mat(images);
Mat channels_mat = channels;
Mat ranges_mat = ranges;
calcBackProject_0(images_mat.nativeObj, channels_mat.nativeObj, hist.nativeObj, dst.nativeObj, ranges_mat.nativeObj, scale);
return;
}
//
// C++: void calcHist(vector_Mat images, vector_int channels, Mat mask, Mat& hist, vector_int histSize, vector_float ranges, bool accumulate = false)
//
//javadoc: calcHist(images, channels, mask, hist, histSize, ranges, accumulate)
public static void calcHist(List<Mat> images, MatOfInt channels, Mat mask, Mat hist, MatOfInt histSize, MatOfFloat ranges, boolean accumulate)
{
Mat images_mat = Converters.vector_Mat_to_Mat(images);
Mat channels_mat = channels;
Mat histSize_mat = histSize;
Mat ranges_mat = ranges;
calcHist_0(images_mat.nativeObj, channels_mat.nativeObj, mask.nativeObj, hist.nativeObj, histSize_mat.nativeObj, ranges_mat.nativeObj, accumulate);
return;
}
//javadoc: calcHist(images, channels, mask, hist, histSize, ranges)
public static void calcHist(List<Mat> images, MatOfInt channels, Mat mask, Mat hist, MatOfInt histSize, MatOfFloat ranges)
{
Mat images_mat = Converters.vector_Mat_to_Mat(images);
Mat channels_mat = channels;
Mat histSize_mat = histSize;
Mat ranges_mat = ranges;
calcHist_1(images_mat.nativeObj, channels_mat.nativeObj, mask.nativeObj, hist.nativeObj, histSize_mat.nativeObj, ranges_mat.nativeObj);
return;
}
//
// C++: void circle(Mat& img, Point center, int radius, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0)
//
//javadoc: circle(img, center, radius, color, thickness, lineType, shift)
public static void circle(Mat img, Point center, int radius, Scalar color, int thickness, int lineType, int shift)
{
circle_0(img.nativeObj, center.x, center.y, radius, color.val[0], color.val[1], color.val[2], color.val[3], thickness, lineType, shift);
return;
}
//javadoc: circle(img, center, radius, color, thickness)
public static void circle(Mat img, Point center, int radius, Scalar color, int thickness)
{
circle_1(img.nativeObj, center.x, center.y, radius, color.val[0], color.val[1], color.val[2], color.val[3], thickness);
return;
}
//javadoc: circle(img, center, radius, color)
public static void circle(Mat img, Point center, int radius, Scalar color)
{
circle_2(img.nativeObj, center.x, center.y, radius, color.val[0], color.val[1], color.val[2], color.val[3]);
return;
}
//
// C++: void convertMaps(Mat map1, Mat map2, Mat& dstmap1, Mat& dstmap2, int dstmap1type, bool nninterpolation = false)
//
//javadoc: convertMaps(map1, map2, dstmap1, dstmap2, dstmap1type, nninterpolation)
public static void convertMaps(Mat map1, Mat map2, Mat dstmap1, Mat dstmap2, int dstmap1type, boolean nninterpolation)
{
convertMaps_0(map1.nativeObj, map2.nativeObj, dstmap1.nativeObj, dstmap2.nativeObj, dstmap1type, nninterpolation);
return;
}
//javadoc: convertMaps(map1, map2, dstmap1, dstmap2, dstmap1type)
public static void convertMaps(Mat map1, Mat map2, Mat dstmap1, Mat dstmap2, int dstmap1type)
{
convertMaps_1(map1.nativeObj, map2.nativeObj, dstmap1.nativeObj, dstmap2.nativeObj, dstmap1type);
return;
}
//
// C++: void convexHull(vector_Point points, vector_int& hull, bool clockwise = false, _hidden_ returnPoints = true)
//
//javadoc: convexHull(points, hull, clockwise)
public static void convexHull(MatOfPoint points, MatOfInt hull, boolean clockwise)
{
Mat points_mat = points;
Mat hull_mat = hull;
convexHull_0(points_mat.nativeObj, hull_mat.nativeObj, clockwise);
return;
}
//javadoc: convexHull(points, hull)
public static void convexHull(MatOfPoint points, MatOfInt hull)
{
Mat points_mat = points;
Mat hull_mat = hull;
convexHull_1(points_mat.nativeObj, hull_mat.nativeObj);
return;
}
//
// C++: void convexityDefects(vector_Point contour, vector_int convexhull, vector_Vec4i& convexityDefects)
//
//javadoc: convexityDefects(contour, convexhull, convexityDefects)
public static void convexityDefects(MatOfPoint contour, MatOfInt convexhull, MatOfInt4 convexityDefects)
{
Mat contour_mat = contour;
Mat convexhull_mat = convexhull;
Mat convexityDefects_mat = convexityDefects;
convexityDefects_0(contour_mat.nativeObj, convexhull_mat.nativeObj, convexityDefects_mat.nativeObj);
return;
}
//
// C++: void cornerEigenValsAndVecs(Mat src, Mat& dst, int blockSize, int ksize, int borderType = BORDER_DEFAULT)
//
//javadoc: cornerEigenValsAndVecs(src, dst, blockSize, ksize, borderType)
public static void cornerEigenValsAndVecs(Mat src, Mat dst, int blockSize, int ksize, int borderType)
{
cornerEigenValsAndVecs_0(src.nativeObj, dst.nativeObj, blockSize, ksize, borderType);
return;
}
//javadoc: cornerEigenValsAndVecs(src, dst, blockSize, ksize)
public static void cornerEigenValsAndVecs(Mat src, Mat dst, int blockSize, int ksize)
{
cornerEigenValsAndVecs_1(src.nativeObj, dst.nativeObj, blockSize, ksize);
return;
}
//
// C++: void cornerHarris(Mat src, Mat& dst, int blockSize, int ksize, double k, int borderType = BORDER_DEFAULT)
//
//javadoc: cornerHarris(src, dst, blockSize, ksize, k, borderType)
public static void cornerHarris(Mat src, Mat dst, int blockSize, int ksize, double k, int borderType)
{
cornerHarris_0(src.nativeObj, dst.nativeObj, blockSize, ksize, k, borderType);
return;
}
//javadoc: cornerHarris(src, dst, blockSize, ksize, k)
public static void cornerHarris(Mat src, Mat dst, int blockSize, int ksize, double k)
{
cornerHarris_1(src.nativeObj, dst.nativeObj, blockSize, ksize, k);
return;
}
//
// C++: void cornerMinEigenVal(Mat src, Mat& dst, int blockSize, int ksize = 3, int borderType = BORDER_DEFAULT)
//
//javadoc: cornerMinEigenVal(src, dst, blockSize, ksize, borderType)
public static void cornerMinEigenVal(Mat src, Mat dst, int blockSize, int ksize, int borderType)
{
cornerMinEigenVal_0(src.nativeObj, dst.nativeObj, blockSize, ksize, borderType);
return;
}
//javadoc: cornerMinEigenVal(src, dst, blockSize, ksize)
public static void cornerMinEigenVal(Mat src, Mat dst, int blockSize, int ksize)
{
cornerMinEigenVal_1(src.nativeObj, dst.nativeObj, blockSize, ksize);
return;
}
//javadoc: cornerMinEigenVal(src, dst, blockSize)
public static void cornerMinEigenVal(Mat src, Mat dst, int blockSize)
{
cornerMinEigenVal_2(src.nativeObj, dst.nativeObj, blockSize);
return;
}
//
// C++: void cornerSubPix(Mat image, vector_Point2f& corners, Size winSize, Size zeroZone, TermCriteria criteria)
//
//javadoc: cornerSubPix(image, corners, winSize, zeroZone, criteria)
public static void cornerSubPix(Mat image, MatOfPoint2f corners, Size winSize, Size zeroZone, TermCriteria criteria)
{
Mat corners_mat = corners;
cornerSubPix_0(image.nativeObj, corners_mat.nativeObj, winSize.width, winSize.height, zeroZone.width, zeroZone.height, criteria.type, criteria.maxCount, criteria.epsilon);
return;
}
//
// C++: void createHanningWindow(Mat& dst, Size winSize, int type)
//
//javadoc: createHanningWindow(dst, winSize, type)
public static void createHanningWindow(Mat dst, Size winSize, int type)
{
createHanningWindow_0(dst.nativeObj, winSize.width, winSize.height, type);
return;
}
//
// C++: void cvtColor(Mat src, Mat& dst, int code, int dstCn = 0)
//
//javadoc: cvtColor(src, dst, code, dstCn)
public static void cvtColor(Mat src, Mat dst, int code, int dstCn)
{
cvtColor_0(src.nativeObj, dst.nativeObj, code, dstCn);
return;
}
//javadoc: cvtColor(src, dst, code)
public static void cvtColor(Mat src, Mat dst, int code)
{
cvtColor_1(src.nativeObj, dst.nativeObj, code);
return;
}
//
// C++: void demosaicing(Mat _src, Mat& _dst, int code, int dcn = 0)
//
//javadoc: demosaicing(_src, _dst, code, dcn)
public static void demosaicing(Mat _src, Mat _dst, int code, int dcn)
{
demosaicing_0(_src.nativeObj, _dst.nativeObj, code, dcn);
return;
}
//javadoc: demosaicing(_src, _dst, code)
public static void demosaicing(Mat _src, Mat _dst, int code)
{
demosaicing_1(_src.nativeObj, _dst.nativeObj, code);
return;
}
//
// C++: void dilate(Mat src, Mat& dst, Mat kernel, Point anchor = Point(-1,-1), int iterations = 1, int borderType = BORDER_CONSTANT, Scalar borderValue = morphologyDefaultBorderValue())
//
//javadoc: dilate(src, dst, kernel, anchor, iterations, borderType, borderValue)
public static void dilate(Mat src, Mat dst, Mat kernel, Point anchor, int iterations, int borderType, Scalar borderValue)
{
dilate_0(src.nativeObj, dst.nativeObj, kernel.nativeObj, anchor.x, anchor.y, iterations, borderType, borderValue.val[0], borderValue.val[1], borderValue.val[2], borderValue.val[3]);
return;
}
//javadoc: dilate(src, dst, kernel, anchor, iterations)
public static void dilate(Mat src, Mat dst, Mat kernel, Point anchor, int iterations)
{
dilate_1(src.nativeObj, dst.nativeObj, kernel.nativeObj, anchor.x, anchor.y, iterations);
return;
}
//javadoc: dilate(src, dst, kernel)
public static void dilate(Mat src, Mat dst, Mat kernel)
{
dilate_2(src.nativeObj, dst.nativeObj, kernel.nativeObj);
return;
}
//
// C++: void distanceTransform(Mat src, Mat& dst, Mat& labels, int distanceType, int maskSize, int labelType = DIST_LABEL_CCOMP)
//
//javadoc: distanceTransform(src, dst, labels, distanceType, maskSize, labelType)
public static void distanceTransformWithLabels(Mat src, Mat dst, Mat labels, int distanceType, int maskSize, int labelType)
{
distanceTransformWithLabels_0(src.nativeObj, dst.nativeObj, labels.nativeObj, distanceType, maskSize, labelType);
return;
}
//javadoc: distanceTransform(src, dst, labels, distanceType, maskSize)
public static void distanceTransformWithLabels(Mat src, Mat dst, Mat labels, int distanceType, int maskSize)
{
distanceTransformWithLabels_1(src.nativeObj, dst.nativeObj, labels.nativeObj, distanceType, maskSize);
return;
}
//
// C++: void distanceTransform(Mat src, Mat& dst, int distanceType, int maskSize, int dstType = CV_32F)
//
//javadoc: distanceTransform(src, dst, distanceType, maskSize, dstType)
public static void distanceTransform(Mat src, Mat dst, int distanceType, int maskSize, int dstType)
{
distanceTransform_0(src.nativeObj, dst.nativeObj, distanceType, maskSize, dstType);
return;
}
//javadoc: distanceTransform(src, dst, distanceType, maskSize)
public static void distanceTransform(Mat src, Mat dst, int distanceType, int maskSize)
{
distanceTransform_1(src.nativeObj, dst.nativeObj, distanceType, maskSize);
return;
}
//
// C++: void drawContours(Mat& image, vector_vector_Point contours, int contourIdx, Scalar color, int thickness = 1, int lineType = LINE_8, Mat hierarchy = Mat(), int maxLevel = INT_MAX, Point offset = Point())
//
//javadoc: drawContours(image, contours, contourIdx, color, thickness, lineType, hierarchy, maxLevel, offset)
public static void drawContours(Mat image, List<MatOfPoint> contours, int contourIdx, Scalar color, int thickness, int lineType, Mat hierarchy, int maxLevel, Point offset)
{
List<Mat> contours_tmplm = new ArrayList<Mat>((contours != null) ? contours.size() : 0);
Mat contours_mat = Converters.vector_vector_Point_to_Mat(contours, contours_tmplm);
drawContours_0(image.nativeObj, contours_mat.nativeObj, contourIdx, color.val[0], color.val[1], color.val[2], color.val[3], thickness, lineType, hierarchy.nativeObj, maxLevel, offset.x, offset.y);
return;
}
//javadoc: drawContours(image, contours, contourIdx, color, thickness)
public static void drawContours(Mat image, List<MatOfPoint> contours, int contourIdx, Scalar color, int thickness)
{
List<Mat> contours_tmplm = new ArrayList<Mat>((contours != null) ? contours.size() : 0);
Mat contours_mat = Converters.vector_vector_Point_to_Mat(contours, contours_tmplm);
drawContours_1(image.nativeObj, contours_mat.nativeObj, contourIdx, color.val[0], color.val[1], color.val[2], color.val[3], thickness);
return;
}
//javadoc: drawContours(image, contours, contourIdx, color)
public static void drawContours(Mat image, List<MatOfPoint> contours, int contourIdx, Scalar color)
{
List<Mat> contours_tmplm = new ArrayList<Mat>((contours != null) ? contours.size() : 0);
Mat contours_mat = Converters.vector_vector_Point_to_Mat(contours, contours_tmplm);
drawContours_2(image.nativeObj, contours_mat.nativeObj, contourIdx, color.val[0], color.val[1], color.val[2], color.val[3]);
return;
}
//
// C++: void drawMarker(Mat& img, Point position, Scalar color, int markerType = MARKER_CROSS, int markerSize = 20, int thickness = 1, int line_type = 8)
//
//javadoc: drawMarker(img, position, color, markerType, markerSize, thickness, line_type)
public static void drawMarker(Mat img, Point position, Scalar color, int markerType, int markerSize, int thickness, int line_type)
{
drawMarker_0(img.nativeObj, position.x, position.y, color.val[0], color.val[1], color.val[2], color.val[3], markerType, markerSize, thickness, line_type);
return;
}
//javadoc: drawMarker(img, position, color)
public static void drawMarker(Mat img, Point position, Scalar color)
{
drawMarker_1(img.nativeObj, position.x, position.y, color.val[0], color.val[1], color.val[2], color.val[3]);
return;
}
//
// C++: void ellipse(Mat& img, Point center, Size axes, double angle, double startAngle, double endAngle, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0)
//
//javadoc: ellipse(img, center, axes, angle, startAngle, endAngle, color, thickness, lineType, shift)
public static void ellipse(Mat img, Point center, Size axes, double angle, double startAngle, double endAngle, Scalar color, int thickness, int lineType, int shift)
{
ellipse_0(img.nativeObj, center.x, center.y, axes.width, axes.height, angle, startAngle, endAngle, color.val[0], color.val[1], color.val[2], color.val[3], thickness, lineType, shift);
return;
}
//javadoc: ellipse(img, center, axes, angle, startAngle, endAngle, color, thickness)
public static void ellipse(Mat img, Point center, Size axes, double angle, double startAngle, double endAngle, Scalar color, int thickness)
{
ellipse_1(img.nativeObj, center.x, center.y, axes.width, axes.height, angle, startAngle, endAngle, color.val[0], color.val[1], color.val[2], color.val[3], thickness);
return;
}
//javadoc: ellipse(img, center, axes, angle, startAngle, endAngle, color)
public static void ellipse(Mat img, Point center, Size axes, double angle, double startAngle, double endAngle, Scalar color)
{
ellipse_2(img.nativeObj, center.x, center.y, axes.width, axes.height, angle, startAngle, endAngle, color.val[0], color.val[1], color.val[2], color.val[3]);
return;
}
//
// C++: void ellipse(Mat& img, RotatedRect box, Scalar color, int thickness = 1, int lineType = LINE_8)
//
//javadoc: ellipse(img, box, color, thickness, lineType)
public static void ellipse(Mat img, RotatedRect box, Scalar color, int thickness, int lineType)
{
ellipse_3(img.nativeObj, box.center.x, box.center.y, box.size.width, box.size.height, box.angle, color.val[0], color.val[1], color.val[2], color.val[3], thickness, lineType);
return;
}
//javadoc: ellipse(img, box, color, thickness)
public static void ellipse(Mat img, RotatedRect box, Scalar color, int thickness)
{
ellipse_4(img.nativeObj, box.center.x, box.center.y, box.size.width, box.size.height, box.angle, color.val[0], color.val[1], color.val[2], color.val[3], thickness);
return;
}
//javadoc: ellipse(img, box, color)
public static void ellipse(Mat img, RotatedRect box, Scalar color)
{
ellipse_5(img.nativeObj, box.center.x, box.center.y, box.size.width, box.size.height, box.angle, color.val[0], color.val[1], color.val[2], color.val[3]);
return;
}
//
// C++: void ellipse2Poly(Point center, Size axes, int angle, int arcStart, int arcEnd, int delta, vector_Point& pts)
//
//javadoc: ellipse2Poly(center, axes, angle, arcStart, arcEnd, delta, pts)
public static void ellipse2Poly(Point center, Size axes, int angle, int arcStart, int arcEnd, int delta, MatOfPoint pts)
{
Mat pts_mat = pts;
ellipse2Poly_0(center.x, center.y, axes.width, axes.height, angle, arcStart, arcEnd, delta, pts_mat.nativeObj);
return;
}
//
// C++: void equalizeHist(Mat src, Mat& dst)
//
//javadoc: equalizeHist(src, dst)
public static void equalizeHist(Mat src, Mat dst)
{
equalizeHist_0(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void erode(Mat src, Mat& dst, Mat kernel, Point anchor = Point(-1,-1), int iterations = 1, int borderType = BORDER_CONSTANT, Scalar borderValue = morphologyDefaultBorderValue())
//
//javadoc: erode(src, dst, kernel, anchor, iterations, borderType, borderValue)
public static void erode(Mat src, Mat dst, Mat kernel, Point anchor, int iterations, int borderType, Scalar borderValue)
{
erode_0(src.nativeObj, dst.nativeObj, kernel.nativeObj, anchor.x, anchor.y, iterations, borderType, borderValue.val[0], borderValue.val[1], borderValue.val[2], borderValue.val[3]);
return;
}
//javadoc: erode(src, dst, kernel, anchor, iterations)
public static void erode(Mat src, Mat dst, Mat kernel, Point anchor, int iterations)
{
erode_1(src.nativeObj, dst.nativeObj, kernel.nativeObj, anchor.x, anchor.y, iterations);
return;
}
//javadoc: erode(src, dst, kernel)
public static void erode(Mat src, Mat dst, Mat kernel)
{
erode_2(src.nativeObj, dst.nativeObj, kernel.nativeObj);
return;
}
//
// C++: void fillConvexPoly(Mat& img, vector_Point points, Scalar color, int lineType = LINE_8, int shift = 0)
//
//javadoc: fillConvexPoly(img, points, color, lineType, shift)
public static void fillConvexPoly(Mat img, MatOfPoint points, Scalar color, int lineType, int shift)
{
Mat points_mat = points;
fillConvexPoly_0(img.nativeObj, points_mat.nativeObj, color.val[0], color.val[1], color.val[2], color.val[3], lineType, shift);
return;
}
//javadoc: fillConvexPoly(img, points, color)
public static void fillConvexPoly(Mat img, MatOfPoint points, Scalar color)
{
Mat points_mat = points;
fillConvexPoly_1(img.nativeObj, points_mat.nativeObj, color.val[0], color.val[1], color.val[2], color.val[3]);
return;
}
//
// C++: void fillPoly(Mat& img, vector_vector_Point pts, Scalar color, int lineType = LINE_8, int shift = 0, Point offset = Point())
//
//javadoc: fillPoly(img, pts, color, lineType, shift, offset)
public static void fillPoly(Mat img, List<MatOfPoint> pts, Scalar color, int lineType, int shift, Point offset)
{
List<Mat> pts_tmplm = new ArrayList<Mat>((pts != null) ? pts.size() : 0);
Mat pts_mat = Converters.vector_vector_Point_to_Mat(pts, pts_tmplm);
fillPoly_0(img.nativeObj, pts_mat.nativeObj, color.val[0], color.val[1], color.val[2], color.val[3], lineType, shift, offset.x, offset.y);
return;
}
//javadoc: fillPoly(img, pts, color)
public static void fillPoly(Mat img, List<MatOfPoint> pts, Scalar color)
{
List<Mat> pts_tmplm = new ArrayList<Mat>((pts != null) ? pts.size() : 0);
Mat pts_mat = Converters.vector_vector_Point_to_Mat(pts, pts_tmplm);
fillPoly_1(img.nativeObj, pts_mat.nativeObj, color.val[0], color.val[1], color.val[2], color.val[3]);
return;
}
//
// C++: void filter2D(Mat src, Mat& dst, int ddepth, Mat kernel, Point anchor = Point(-1,-1), double delta = 0, int borderType = BORDER_DEFAULT)
//
//javadoc: filter2D(src, dst, ddepth, kernel, anchor, delta, borderType)
public static void filter2D(Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, double delta, int borderType)
{
filter2D_0(src.nativeObj, dst.nativeObj, ddepth, kernel.nativeObj, anchor.x, anchor.y, delta, borderType);
return;
}
//javadoc: filter2D(src, dst, ddepth, kernel, anchor, delta)
public static void filter2D(Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, double delta)
{
filter2D_1(src.nativeObj, dst.nativeObj, ddepth, kernel.nativeObj, anchor.x, anchor.y, delta);
return;
}
//javadoc: filter2D(src, dst, ddepth, kernel)
public static void filter2D(Mat src, Mat dst, int ddepth, Mat kernel)
{
filter2D_2(src.nativeObj, dst.nativeObj, ddepth, kernel.nativeObj);
return;
}
//
// C++: void findContours(Mat& image, vector_vector_Point& contours, Mat& hierarchy, int mode, int method, Point offset = Point())
//
//javadoc: findContours(image, contours, hierarchy, mode, method, offset)
public static void findContours(Mat image, List<MatOfPoint> contours, Mat hierarchy, int mode, int method, Point offset)
{
Mat contours_mat = new Mat();
findContours_0(image.nativeObj, contours_mat.nativeObj, hierarchy.nativeObj, mode, method, offset.x, offset.y);
Converters.Mat_to_vector_vector_Point(contours_mat, contours);
contours_mat.release();
return;
}
//javadoc: findContours(image, contours, hierarchy, mode, method)
public static void findContours(Mat image, List<MatOfPoint> contours, Mat hierarchy, int mode, int method)
{
Mat contours_mat = new Mat();
findContours_1(image.nativeObj, contours_mat.nativeObj, hierarchy.nativeObj, mode, method);
Converters.Mat_to_vector_vector_Point(contours_mat, contours);
contours_mat.release();
return;
}
//
// C++: void fitLine(Mat points, Mat& line, int distType, double param, double reps, double aeps)
//
//javadoc: fitLine(points, line, distType, param, reps, aeps)
public static void fitLine(Mat points, Mat line, int distType, double param, double reps, double aeps)
{
fitLine_0(points.nativeObj, line.nativeObj, distType, param, reps, aeps);
return;
}
//
// C++: void getDerivKernels(Mat& kx, Mat& ky, int dx, int dy, int ksize, bool normalize = false, int ktype = CV_32F)
//
//javadoc: getDerivKernels(kx, ky, dx, dy, ksize, normalize, ktype)
public static void getDerivKernels(Mat kx, Mat ky, int dx, int dy, int ksize, boolean normalize, int ktype)
{
getDerivKernels_0(kx.nativeObj, ky.nativeObj, dx, dy, ksize, normalize, ktype);
return;
}
//javadoc: getDerivKernels(kx, ky, dx, dy, ksize)
public static void getDerivKernels(Mat kx, Mat ky, int dx, int dy, int ksize)
{
getDerivKernels_1(kx.nativeObj, ky.nativeObj, dx, dy, ksize);
return;
}
//
// C++: void getRectSubPix(Mat image, Size patchSize, Point2f center, Mat& patch, int patchType = -1)
//
//javadoc: getRectSubPix(image, patchSize, center, patch, patchType)
public static void getRectSubPix(Mat image, Size patchSize, Point center, Mat patch, int patchType)
{
getRectSubPix_0(image.nativeObj, patchSize.width, patchSize.height, center.x, center.y, patch.nativeObj, patchType);
return;
}
//javadoc: getRectSubPix(image, patchSize, center, patch)
public static void getRectSubPix(Mat image, Size patchSize, Point center, Mat patch)
{
getRectSubPix_1(image.nativeObj, patchSize.width, patchSize.height, center.x, center.y, patch.nativeObj);
return;
}
//
// C++: void goodFeaturesToTrack(Mat image, vector_Point& corners, int maxCorners, double qualityLevel, double minDistance, Mat mask = Mat(), int blockSize = 3, bool useHarrisDetector = false, double k = 0.04)
//
//javadoc: goodFeaturesToTrack(image, corners, maxCorners, qualityLevel, minDistance, mask, blockSize, useHarrisDetector, k)
public static void goodFeaturesToTrack(Mat image, MatOfPoint corners, int maxCorners, double qualityLevel, double minDistance, Mat mask, int blockSize, boolean useHarrisDetector, double k)
{
Mat corners_mat = corners;
goodFeaturesToTrack_0(image.nativeObj, corners_mat.nativeObj, maxCorners, qualityLevel, minDistance, mask.nativeObj, blockSize, useHarrisDetector, k);
return;
}
//javadoc: goodFeaturesToTrack(image, corners, maxCorners, qualityLevel, minDistance)
public static void goodFeaturesToTrack(Mat image, MatOfPoint corners, int maxCorners, double qualityLevel, double minDistance)
{
Mat corners_mat = corners;
goodFeaturesToTrack_1(image.nativeObj, corners_mat.nativeObj, maxCorners, qualityLevel, minDistance);
return;
}
//
// C++: void grabCut(Mat img, Mat& mask, Rect rect, Mat& bgdModel, Mat& fgdModel, int iterCount, int mode = GC_EVAL)
//
//javadoc: grabCut(img, mask, rect, bgdModel, fgdModel, iterCount, mode)
public static void grabCut(Mat img, Mat mask, Rect rect, Mat bgdModel, Mat fgdModel, int iterCount, int mode)
{
grabCut_0(img.nativeObj, mask.nativeObj, rect.x, rect.y, rect.width, rect.height, bgdModel.nativeObj, fgdModel.nativeObj, iterCount, mode);
return;
}
//javadoc: grabCut(img, mask, rect, bgdModel, fgdModel, iterCount)
public static void grabCut(Mat img, Mat mask, Rect rect, Mat bgdModel, Mat fgdModel, int iterCount)
{
grabCut_1(img.nativeObj, mask.nativeObj, rect.x, rect.y, rect.width, rect.height, bgdModel.nativeObj, fgdModel.nativeObj, iterCount);
return;
}
//
// C++: void initUndistortRectifyMap(Mat cameraMatrix, Mat distCoeffs, Mat R, Mat newCameraMatrix, Size size, int m1type, Mat& map1, Mat& map2)
//
//javadoc: initUndistortRectifyMap(cameraMatrix, distCoeffs, R, newCameraMatrix, size, m1type, map1, map2)
public static void initUndistortRectifyMap(Mat cameraMatrix, Mat distCoeffs, Mat R, Mat newCameraMatrix, Size size, int m1type, Mat map1, Mat map2)
{
initUndistortRectifyMap_0(cameraMatrix.nativeObj, distCoeffs.nativeObj, R.nativeObj, newCameraMatrix.nativeObj, size.width, size.height, m1type, map1.nativeObj, map2.nativeObj);
return;
}
//
// C++: void integral(Mat src, Mat& sum, Mat& sqsum, Mat& tilted, int sdepth = -1, int sqdepth = -1)
//
//javadoc: integral(src, sum, sqsum, tilted, sdepth, sqdepth)
public static void integral3(Mat src, Mat sum, Mat sqsum, Mat tilted, int sdepth, int sqdepth)
{
integral3_0(src.nativeObj, sum.nativeObj, sqsum.nativeObj, tilted.nativeObj, sdepth, sqdepth);
return;
}
//javadoc: integral(src, sum, sqsum, tilted)
public static void integral3(Mat src, Mat sum, Mat sqsum, Mat tilted)
{
integral3_1(src.nativeObj, sum.nativeObj, sqsum.nativeObj, tilted.nativeObj);
return;
}
//
// C++: void integral(Mat src, Mat& sum, Mat& sqsum, int sdepth = -1, int sqdepth = -1)
//
//javadoc: integral(src, sum, sqsum, sdepth, sqdepth)
public static void integral2(Mat src, Mat sum, Mat sqsum, int sdepth, int sqdepth)
{
integral2_0(src.nativeObj, sum.nativeObj, sqsum.nativeObj, sdepth, sqdepth);
return;
}
//javadoc: integral(src, sum, sqsum)
public static void integral2(Mat src, Mat sum, Mat sqsum)
{
integral2_1(src.nativeObj, sum.nativeObj, sqsum.nativeObj);
return;
}
//
// C++: void integral(Mat src, Mat& sum, int sdepth = -1)
//
//javadoc: integral(src, sum, sdepth)
public static void integral(Mat src, Mat sum, int sdepth)
{
integral_0(src.nativeObj, sum.nativeObj, sdepth);
return;
}
//javadoc: integral(src, sum)
public static void integral(Mat src, Mat sum)
{
integral_1(src.nativeObj, sum.nativeObj);
return;
}
//
// C++: void invertAffineTransform(Mat M, Mat& iM)
//
//javadoc: invertAffineTransform(M, iM)
public static void invertAffineTransform(Mat M, Mat iM)
{
invertAffineTransform_0(M.nativeObj, iM.nativeObj);
return;
}
//
// C++: void line(Mat& img, Point pt1, Point pt2, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0)
//
//javadoc: line(img, pt1, pt2, color, thickness, lineType, shift)
public static void line(Mat img, Point pt1, Point pt2, Scalar color, int thickness, int lineType, int shift)
{
line_0(img.nativeObj, pt1.x, pt1.y, pt2.x, pt2.y, color.val[0], color.val[1], color.val[2], color.val[3], thickness, lineType, shift);
return;
}
//javadoc: line(img, pt1, pt2, color, thickness)
public static void line(Mat img, Point pt1, Point pt2, Scalar color, int thickness)
{
line_1(img.nativeObj, pt1.x, pt1.y, pt2.x, pt2.y, color.val[0], color.val[1], color.val[2], color.val[3], thickness);
return;
}
//javadoc: line(img, pt1, pt2, color)
public static void line(Mat img, Point pt1, Point pt2, Scalar color)
{
line_2(img.nativeObj, pt1.x, pt1.y, pt2.x, pt2.y, color.val[0], color.val[1], color.val[2], color.val[3]);
return;
}
//
// C++: void linearPolar(Mat src, Mat& dst, Point2f center, double maxRadius, int flags)
//
//javadoc: linearPolar(src, dst, center, maxRadius, flags)
public static void linearPolar(Mat src, Mat dst, Point center, double maxRadius, int flags)
{
linearPolar_0(src.nativeObj, dst.nativeObj, center.x, center.y, maxRadius, flags);
return;
}
//
// C++: void logPolar(Mat src, Mat& dst, Point2f center, double M, int flags)
//
//javadoc: logPolar(src, dst, center, M, flags)
public static void logPolar(Mat src, Mat dst, Point center, double M, int flags)
{
logPolar_0(src.nativeObj, dst.nativeObj, center.x, center.y, M, flags);
return;
}
//
// C++: void matchTemplate(Mat image, Mat templ, Mat& result, int method, Mat mask = Mat())
//
//javadoc: matchTemplate(image, templ, result, method, mask)
public static void matchTemplate(Mat image, Mat templ, Mat result, int method, Mat mask)
{
matchTemplate_0(image.nativeObj, templ.nativeObj, result.nativeObj, method, mask.nativeObj);
return;
}
//javadoc: matchTemplate(image, templ, result, method)
public static void matchTemplate(Mat image, Mat templ, Mat result, int method)
{
matchTemplate_1(image.nativeObj, templ.nativeObj, result.nativeObj, method);
return;
}
//
// C++: void medianBlur(Mat src, Mat& dst, int ksize)
//
//javadoc: medianBlur(src, dst, ksize)
public static void medianBlur(Mat src, Mat dst, int ksize)
{
medianBlur_0(src.nativeObj, dst.nativeObj, ksize);
return;
}
//
// C++: void minEnclosingCircle(vector_Point2f points, Point2f& center, float& radius)
//
//javadoc: minEnclosingCircle(points, center, radius)
public static void minEnclosingCircle(MatOfPoint2f points, Point center, float[] radius)
{
Mat points_mat = points;
double[] center_out = new double[2];
double[] radius_out = new double[1];
minEnclosingCircle_0(points_mat.nativeObj, center_out, radius_out);
if(center!=null){ center.x = center_out[0]; center.y = center_out[1]; }
if(radius!=null) radius[0] = (float)radius_out[0];
return;
}
//
// C++: void morphologyEx(Mat src, Mat& dst, int op, Mat kernel, Point anchor = Point(-1,-1), int iterations = 1, int borderType = BORDER_CONSTANT, Scalar borderValue = morphologyDefaultBorderValue())
//
//javadoc: morphologyEx(src, dst, op, kernel, anchor, iterations, borderType, borderValue)
public static void morphologyEx(Mat src, Mat dst, int op, Mat kernel, Point anchor, int iterations, int borderType, Scalar borderValue)
{
morphologyEx_0(src.nativeObj, dst.nativeObj, op, kernel.nativeObj, anchor.x, anchor.y, iterations, borderType, borderValue.val[0], borderValue.val[1], borderValue.val[2], borderValue.val[3]);
return;
}
//javadoc: morphologyEx(src, dst, op, kernel, anchor, iterations)
public static void morphologyEx(Mat src, Mat dst, int op, Mat kernel, Point anchor, int iterations)
{
morphologyEx_1(src.nativeObj, dst.nativeObj, op, kernel.nativeObj, anchor.x, anchor.y, iterations);
return;
}
//javadoc: morphologyEx(src, dst, op, kernel)
public static void morphologyEx(Mat src, Mat dst, int op, Mat kernel)
{
morphologyEx_2(src.nativeObj, dst.nativeObj, op, kernel.nativeObj);
return;
}
//
// C++: void polylines(Mat& img, vector_vector_Point pts, bool isClosed, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0)
//
//javadoc: polylines(img, pts, isClosed, color, thickness, lineType, shift)
public static void polylines(Mat img, List<MatOfPoint> pts, boolean isClosed, Scalar color, int thickness, int lineType, int shift)
{
List<Mat> pts_tmplm = new ArrayList<Mat>((pts != null) ? pts.size() : 0);
Mat pts_mat = Converters.vector_vector_Point_to_Mat(pts, pts_tmplm);
polylines_0(img.nativeObj, pts_mat.nativeObj, isClosed, color.val[0], color.val[1], color.val[2], color.val[3], thickness, lineType, shift);
return;
}
//javadoc: polylines(img, pts, isClosed, color, thickness)
public static void polylines(Mat img, List<MatOfPoint> pts, boolean isClosed, Scalar color, int thickness)
{
List<Mat> pts_tmplm = new ArrayList<Mat>((pts != null) ? pts.size() : 0);
Mat pts_mat = Converters.vector_vector_Point_to_Mat(pts, pts_tmplm);
polylines_1(img.nativeObj, pts_mat.nativeObj, isClosed, color.val[0], color.val[1], color.val[2], color.val[3], thickness);
return;
}
//javadoc: polylines(img, pts, isClosed, color)
public static void polylines(Mat img, List<MatOfPoint> pts, boolean isClosed, Scalar color)
{
List<Mat> pts_tmplm = new ArrayList<Mat>((pts != null) ? pts.size() : 0);
Mat pts_mat = Converters.vector_vector_Point_to_Mat(pts, pts_tmplm);
polylines_2(img.nativeObj, pts_mat.nativeObj, isClosed, color.val[0], color.val[1], color.val[2], color.val[3]);
return;
}
//
// C++: void preCornerDetect(Mat src, Mat& dst, int ksize, int borderType = BORDER_DEFAULT)
//
//javadoc: preCornerDetect(src, dst, ksize, borderType)
public static void preCornerDetect(Mat src, Mat dst, int ksize, int borderType)
{
preCornerDetect_0(src.nativeObj, dst.nativeObj, ksize, borderType);
return;
}
//javadoc: preCornerDetect(src, dst, ksize)
public static void preCornerDetect(Mat src, Mat dst, int ksize)
{
preCornerDetect_1(src.nativeObj, dst.nativeObj, ksize);
return;
}
//
// C++: void putText(Mat& img, String text, Point org, int fontFace, double fontScale, Scalar color, int thickness = 1, int lineType = LINE_8, bool bottomLeftOrigin = false)
//
//javadoc: putText(img, text, org, fontFace, fontScale, color, thickness, lineType, bottomLeftOrigin)
public static void putText(Mat img, String text, Point org, int fontFace, double fontScale, Scalar color, int thickness, int lineType, boolean bottomLeftOrigin)
{
putText_0(img.nativeObj, text, org.x, org.y, fontFace, fontScale, color.val[0], color.val[1], color.val[2], color.val[3], thickness, lineType, bottomLeftOrigin);
return;
}
//javadoc: putText(img, text, org, fontFace, fontScale, color, thickness)
public static void putText(Mat img, String text, Point org, int fontFace, double fontScale, Scalar color, int thickness)
{
putText_1(img.nativeObj, text, org.x, org.y, fontFace, fontScale, color.val[0], color.val[1], color.val[2], color.val[3], thickness);
return;
}
//javadoc: putText(img, text, org, fontFace, fontScale, color)
public static void putText(Mat img, String text, Point org, int fontFace, double fontScale, Scalar color)
{
putText_2(img.nativeObj, text, org.x, org.y, fontFace, fontScale, color.val[0], color.val[1], color.val[2], color.val[3]);
return;
}
//
// C++: void pyrDown(Mat src, Mat& dst, Size dstsize = Size(), int borderType = BORDER_DEFAULT)
//
//javadoc: pyrDown(src, dst, dstsize, borderType)
public static void pyrDown(Mat src, Mat dst, Size dstsize, int borderType)
{
pyrDown_0(src.nativeObj, dst.nativeObj, dstsize.width, dstsize.height, borderType);
return;
}
//javadoc: pyrDown(src, dst, dstsize)
public static void pyrDown(Mat src, Mat dst, Size dstsize)
{
pyrDown_1(src.nativeObj, dst.nativeObj, dstsize.width, dstsize.height);
return;
}
//javadoc: pyrDown(src, dst)
public static void pyrDown(Mat src, Mat dst)
{
pyrDown_2(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void pyrMeanShiftFiltering(Mat src, Mat& dst, double sp, double sr, int maxLevel = 1, TermCriteria termcrit = TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS,5,1))
//
//javadoc: pyrMeanShiftFiltering(src, dst, sp, sr, maxLevel, termcrit)
public static void pyrMeanShiftFiltering(Mat src, Mat dst, double sp, double sr, int maxLevel, TermCriteria termcrit)
{
pyrMeanShiftFiltering_0(src.nativeObj, dst.nativeObj, sp, sr, maxLevel, termcrit.type, termcrit.maxCount, termcrit.epsilon);
return;
}
//javadoc: pyrMeanShiftFiltering(src, dst, sp, sr)
public static void pyrMeanShiftFiltering(Mat src, Mat dst, double sp, double sr)
{
pyrMeanShiftFiltering_1(src.nativeObj, dst.nativeObj, sp, sr);
return;
}
//
// C++: void pyrUp(Mat src, Mat& dst, Size dstsize = Size(), int borderType = BORDER_DEFAULT)
//
//javadoc: pyrUp(src, dst, dstsize, borderType)
public static void pyrUp(Mat src, Mat dst, Size dstsize, int borderType)
{
pyrUp_0(src.nativeObj, dst.nativeObj, dstsize.width, dstsize.height, borderType);
return;
}
//javadoc: pyrUp(src, dst, dstsize)
public static void pyrUp(Mat src, Mat dst, Size dstsize)
{
pyrUp_1(src.nativeObj, dst.nativeObj, dstsize.width, dstsize.height);
return;
}
//javadoc: pyrUp(src, dst)
public static void pyrUp(Mat src, Mat dst)
{
pyrUp_2(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void rectangle(Mat& img, Point pt1, Point pt2, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0)
//
//javadoc: rectangle(img, pt1, pt2, color, thickness, lineType, shift)
public static void rectangle(Mat img, Point pt1, Point pt2, Scalar color, int thickness, int lineType, int shift)
{
rectangle_0(img.nativeObj, pt1.x, pt1.y, pt2.x, pt2.y, color.val[0], color.val[1], color.val[2], color.val[3], thickness, lineType, shift);
return;
}
//javadoc: rectangle(img, pt1, pt2, color, thickness)
public static void rectangle(Mat img, Point pt1, Point pt2, Scalar color, int thickness)
{
rectangle_1(img.nativeObj, pt1.x, pt1.y, pt2.x, pt2.y, color.val[0], color.val[1], color.val[2], color.val[3], thickness);
return;
}
//javadoc: rectangle(img, pt1, pt2, color)
public static void rectangle(Mat img, Point pt1, Point pt2, Scalar color)
{
rectangle_2(img.nativeObj, pt1.x, pt1.y, pt2.x, pt2.y, color.val[0], color.val[1], color.val[2], color.val[3]);
return;
}
//
// C++: void remap(Mat src, Mat& dst, Mat map1, Mat map2, int interpolation, int borderMode = BORDER_CONSTANT, Scalar borderValue = Scalar())
//
//javadoc: remap(src, dst, map1, map2, interpolation, borderMode, borderValue)
public static void remap(Mat src, Mat dst, Mat map1, Mat map2, int interpolation, int borderMode, Scalar borderValue)
{
remap_0(src.nativeObj, dst.nativeObj, map1.nativeObj, map2.nativeObj, interpolation, borderMode, borderValue.val[0], borderValue.val[1], borderValue.val[2], borderValue.val[3]);
return;
}
//javadoc: remap(src, dst, map1, map2, interpolation)
public static void remap(Mat src, Mat dst, Mat map1, Mat map2, int interpolation)
{
remap_1(src.nativeObj, dst.nativeObj, map1.nativeObj, map2.nativeObj, interpolation);
return;
}
//
// C++: void resize(Mat src, Mat& dst, Size dsize, double fx = 0, double fy = 0, int interpolation = INTER_LINEAR)
//
//javadoc: resize(src, dst, dsize, fx, fy, interpolation)
public static void resize(Mat src, Mat dst, Size dsize, double fx, double fy, int interpolation)
{
resize_0(src.nativeObj, dst.nativeObj, dsize.width, dsize.height, fx, fy, interpolation);
return;
}
//javadoc: resize(src, dst, dsize)
public static void resize(Mat src, Mat dst, Size dsize)
{
resize_1(src.nativeObj, dst.nativeObj, dsize.width, dsize.height);
return;
}
//
// C++: void sepFilter2D(Mat src, Mat& dst, int ddepth, Mat kernelX, Mat kernelY, Point anchor = Point(-1,-1), double delta = 0, int borderType = BORDER_DEFAULT)
//
//javadoc: sepFilter2D(src, dst, ddepth, kernelX, kernelY, anchor, delta, borderType)
public static void sepFilter2D(Mat src, Mat dst, int ddepth, Mat kernelX, Mat kernelY, Point anchor, double delta, int borderType)
{
sepFilter2D_0(src.nativeObj, dst.nativeObj, ddepth, kernelX.nativeObj, kernelY.nativeObj, anchor.x, anchor.y, delta, borderType);
return;
}
//javadoc: sepFilter2D(src, dst, ddepth, kernelX, kernelY, anchor, delta)
public static void sepFilter2D(Mat src, Mat dst, int ddepth, Mat kernelX, Mat kernelY, Point anchor, double delta)
{
sepFilter2D_1(src.nativeObj, dst.nativeObj, ddepth, kernelX.nativeObj, kernelY.nativeObj, anchor.x, anchor.y, delta);
return;
}
//javadoc: sepFilter2D(src, dst, ddepth, kernelX, kernelY)
public static void sepFilter2D(Mat src, Mat dst, int ddepth, Mat kernelX, Mat kernelY)
{
sepFilter2D_2(src.nativeObj, dst.nativeObj, ddepth, kernelX.nativeObj, kernelY.nativeObj);
return;
}
//
// C++: void spatialGradient(Mat src, Mat& dx, Mat& dy, int ksize = 3, int borderType = BORDER_DEFAULT)
//
//javadoc: spatialGradient(src, dx, dy, ksize, borderType)
public static void spatialGradient(Mat src, Mat dx, Mat dy, int ksize, int borderType)
{
spatialGradient_0(src.nativeObj, dx.nativeObj, dy.nativeObj, ksize, borderType);
return;
}
//javadoc: spatialGradient(src, dx, dy, ksize)
public static void spatialGradient(Mat src, Mat dx, Mat dy, int ksize)
{
spatialGradient_1(src.nativeObj, dx.nativeObj, dy.nativeObj, ksize);
return;
}
//javadoc: spatialGradient(src, dx, dy)
public static void spatialGradient(Mat src, Mat dx, Mat dy)
{
spatialGradient_2(src.nativeObj, dx.nativeObj, dy.nativeObj);
return;
}
//
// C++: void sqrBoxFilter(Mat _src, Mat& _dst, int ddepth, Size ksize, Point anchor = Point(-1, -1), bool normalize = true, int borderType = BORDER_DEFAULT)
//
//javadoc: sqrBoxFilter(_src, _dst, ddepth, ksize, anchor, normalize, borderType)
public static void sqrBoxFilter(Mat _src, Mat _dst, int ddepth, Size ksize, Point anchor, boolean normalize, int borderType)
{
sqrBoxFilter_0(_src.nativeObj, _dst.nativeObj, ddepth, ksize.width, ksize.height, anchor.x, anchor.y, normalize, borderType);
return;
}
//javadoc: sqrBoxFilter(_src, _dst, ddepth, ksize, anchor, normalize)
public static void sqrBoxFilter(Mat _src, Mat _dst, int ddepth, Size ksize, Point anchor, boolean normalize)
{
sqrBoxFilter_1(_src.nativeObj, _dst.nativeObj, ddepth, ksize.width, ksize.height, anchor.x, anchor.y, normalize);
return;
}
//javadoc: sqrBoxFilter(_src, _dst, ddepth, ksize)
public static void sqrBoxFilter(Mat _src, Mat _dst, int ddepth, Size ksize)
{
sqrBoxFilter_2(_src.nativeObj, _dst.nativeObj, ddepth, ksize.width, ksize.height);
return;
}
//
// C++: void undistort(Mat src, Mat& dst, Mat cameraMatrix, Mat distCoeffs, Mat newCameraMatrix = Mat())
//
//javadoc: undistort(src, dst, cameraMatrix, distCoeffs, newCameraMatrix)
public static void undistort(Mat src, Mat dst, Mat cameraMatrix, Mat distCoeffs, Mat newCameraMatrix)
{
undistort_0(src.nativeObj, dst.nativeObj, cameraMatrix.nativeObj, distCoeffs.nativeObj, newCameraMatrix.nativeObj);
return;
}
//javadoc: undistort(src, dst, cameraMatrix, distCoeffs)
public static void undistort(Mat src, Mat dst, Mat cameraMatrix, Mat distCoeffs)
{
undistort_1(src.nativeObj, dst.nativeObj, cameraMatrix.nativeObj, distCoeffs.nativeObj);
return;
}
//
// C++: void undistortPoints(vector_Point2f src, vector_Point2f& dst, Mat cameraMatrix, Mat distCoeffs, Mat R = Mat(), Mat P = Mat())
//
//javadoc: undistortPoints(src, dst, cameraMatrix, distCoeffs, R, P)
public static void undistortPoints(MatOfPoint2f src, MatOfPoint2f dst, Mat cameraMatrix, Mat distCoeffs, Mat R, Mat P)
{
Mat src_mat = src;
Mat dst_mat = dst;
undistortPoints_0(src_mat.nativeObj, dst_mat.nativeObj, cameraMatrix.nativeObj, distCoeffs.nativeObj, R.nativeObj, P.nativeObj);
return;
}
//javadoc: undistortPoints(src, dst, cameraMatrix, distCoeffs)
public static void undistortPoints(MatOfPoint2f src, MatOfPoint2f dst, Mat cameraMatrix, Mat distCoeffs)
{
Mat src_mat = src;
Mat dst_mat = dst;
undistortPoints_1(src_mat.nativeObj, dst_mat.nativeObj, cameraMatrix.nativeObj, distCoeffs.nativeObj);
return;
}
//
// C++: void warpAffine(Mat src, Mat& dst, Mat M, Size dsize, int flags = INTER_LINEAR, int borderMode = BORDER_CONSTANT, Scalar borderValue = Scalar())
//
//javadoc: warpAffine(src, dst, M, dsize, flags, borderMode, borderValue)
public static void warpAffine(Mat src, Mat dst, Mat M, Size dsize, int flags, int borderMode, Scalar borderValue)
{
warpAffine_0(src.nativeObj, dst.nativeObj, M.nativeObj, dsize.width, dsize.height, flags, borderMode, borderValue.val[0], borderValue.val[1], borderValue.val[2], borderValue.val[3]);
return;
}
//javadoc: warpAffine(src, dst, M, dsize, flags)
public static void warpAffine(Mat src, Mat dst, Mat M, Size dsize, int flags)
{
warpAffine_1(src.nativeObj, dst.nativeObj, M.nativeObj, dsize.width, dsize.height, flags);
return;
}
//javadoc: warpAffine(src, dst, M, dsize)
public static void warpAffine(Mat src, Mat dst, Mat M, Size dsize)
{
warpAffine_2(src.nativeObj, dst.nativeObj, M.nativeObj, dsize.width, dsize.height);
return;
}
//
// C++: void warpPerspective(Mat src, Mat& dst, Mat M, Size dsize, int flags = INTER_LINEAR, int borderMode = BORDER_CONSTANT, Scalar borderValue = Scalar())
//
//javadoc: warpPerspective(src, dst, M, dsize, flags, borderMode, borderValue)
public static void warpPerspective(Mat src, Mat dst, Mat M, Size dsize, int flags, int borderMode, Scalar borderValue)
{
warpPerspective_0(src.nativeObj, dst.nativeObj, M.nativeObj, dsize.width, dsize.height, flags, borderMode, borderValue.val[0], borderValue.val[1], borderValue.val[2], borderValue.val[3]);
return;
}
//javadoc: warpPerspective(src, dst, M, dsize, flags)
public static void warpPerspective(Mat src, Mat dst, Mat M, Size dsize, int flags)
{
warpPerspective_1(src.nativeObj, dst.nativeObj, M.nativeObj, dsize.width, dsize.height, flags);
return;
}
//javadoc: warpPerspective(src, dst, M, dsize)
public static void warpPerspective(Mat src, Mat dst, Mat M, Size dsize)
{
warpPerspective_2(src.nativeObj, dst.nativeObj, M.nativeObj, dsize.width, dsize.height);
return;
}
//
// C++: void watershed(Mat image, Mat& markers)
//
//javadoc: watershed(image, markers)
public static void watershed(Mat image, Mat markers)
{
watershed_0(image.nativeObj, markers.nativeObj);
return;
}
// C++: Size getTextSize(const String& text, int fontFace, double fontScale, int thickness, int* baseLine);
//javadoc:getTextSize(text, fontFace, fontScale, thickness, baseLine)
public static Size getTextSize(String text, int fontFace, double fontScale, int thickness, int[] baseLine) {
if(baseLine != null && baseLine.length != 1)
throw new java.lang.IllegalArgumentException("'baseLine' must be 'int[1]' or 'null'.");
Size retVal = new Size(n_getTextSize(text, fontFace, fontScale, thickness, baseLine));
return retVal;
}
// C++: Mat getAffineTransform(vector_Point2f src, vector_Point2f dst)
private static native long getAffineTransform_0(long src_mat_nativeObj, long dst_mat_nativeObj);
// C++: Mat getDefaultNewCameraMatrix(Mat cameraMatrix, Size imgsize = Size(), bool centerPrincipalPoint = false)
private static native long getDefaultNewCameraMatrix_0(long cameraMatrix_nativeObj, double imgsize_width, double imgsize_height, boolean centerPrincipalPoint);
private static native long getDefaultNewCameraMatrix_1(long cameraMatrix_nativeObj);
// C++: Mat getGaborKernel(Size ksize, double sigma, double theta, double lambd, double gamma, double psi = CV_PI*0.5, int ktype = CV_64F)
private static native long getGaborKernel_0(double ksize_width, double ksize_height, double sigma, double theta, double lambd, double gamma, double psi, int ktype);
private static native long getGaborKernel_1(double ksize_width, double ksize_height, double sigma, double theta, double lambd, double gamma);
// C++: Mat getGaussianKernel(int ksize, double sigma, int ktype = CV_64F)
private static native long getGaussianKernel_0(int ksize, double sigma, int ktype);
private static native long getGaussianKernel_1(int ksize, double sigma);
// C++: Mat getPerspectiveTransform(Mat src, Mat dst)
private static native long getPerspectiveTransform_0(long src_nativeObj, long dst_nativeObj);
// C++: Mat getRotationMatrix2D(Point2f center, double angle, double scale)
private static native long getRotationMatrix2D_0(double center_x, double center_y, double angle, double scale);
// C++: Mat getStructuringElement(int shape, Size ksize, Point anchor = Point(-1,-1))
private static native long getStructuringElement_0(int shape, double ksize_width, double ksize_height, double anchor_x, double anchor_y);
private static native long getStructuringElement_1(int shape, double ksize_width, double ksize_height);
// C++: Moments moments(Mat array, bool binaryImage = false)
private static native double[] moments_0(long array_nativeObj, boolean binaryImage);
private static native double[] moments_1(long array_nativeObj);
// C++: Point2d phaseCorrelate(Mat src1, Mat src2, Mat window = Mat(), double* response = 0)
private static native double[] phaseCorrelate_0(long src1_nativeObj, long src2_nativeObj, long window_nativeObj, double[] response_out);
private static native double[] phaseCorrelate_1(long src1_nativeObj, long src2_nativeObj);
// C++: Ptr_CLAHE createCLAHE(double clipLimit = 40.0, Size tileGridSize = Size(8, 8))
private static native long createCLAHE_0(double clipLimit, double tileGridSize_width, double tileGridSize_height);
private static native long createCLAHE_1();
// C++: Ptr_LineSegmentDetector createLineSegmentDetector(int _refine = LSD_REFINE_STD, double _scale = 0.8, double _sigma_scale = 0.6, double _quant = 2.0, double _ang_th = 22.5, double _log_eps = 0, double _density_th = 0.7, int _n_bins = 1024)
private static native long createLineSegmentDetector_0(int _refine, double _scale, double _sigma_scale, double _quant, double _ang_th, double _log_eps, double _density_th, int _n_bins);
private static native long createLineSegmentDetector_1();
// C++: Rect boundingRect(vector_Point points)
private static native double[] boundingRect_0(long points_mat_nativeObj);
// C++: RotatedRect fitEllipse(vector_Point2f points)
private static native double[] fitEllipse_0(long points_mat_nativeObj);
// C++: RotatedRect minAreaRect(vector_Point2f points)
private static native double[] minAreaRect_0(long points_mat_nativeObj);
// C++: bool clipLine(Rect imgRect, Point& pt1, Point& pt2)
private static native boolean clipLine_0(int imgRect_x, int imgRect_y, int imgRect_width, int imgRect_height, double pt1_x, double pt1_y, double[] pt1_out, double pt2_x, double pt2_y, double[] pt2_out);
// C++: bool isContourConvex(vector_Point contour)
private static native boolean isContourConvex_0(long contour_mat_nativeObj);
// C++: double arcLength(vector_Point2f curve, bool closed)
private static native double arcLength_0(long curve_mat_nativeObj, boolean closed);
// C++: double compareHist(Mat H1, Mat H2, int method)
private static native double compareHist_0(long H1_nativeObj, long H2_nativeObj, int method);
// C++: double contourArea(Mat contour, bool oriented = false)
private static native double contourArea_0(long contour_nativeObj, boolean oriented);
private static native double contourArea_1(long contour_nativeObj);
// C++: double matchShapes(Mat contour1, Mat contour2, int method, double parameter)
private static native double matchShapes_0(long contour1_nativeObj, long contour2_nativeObj, int method, double parameter);
// C++: double minEnclosingTriangle(Mat points, Mat& triangle)
private static native double minEnclosingTriangle_0(long points_nativeObj, long triangle_nativeObj);
// C++: double pointPolygonTest(vector_Point2f contour, Point2f pt, bool measureDist)
private static native double pointPolygonTest_0(long contour_mat_nativeObj, double pt_x, double pt_y, boolean measureDist);
// C++: double threshold(Mat src, Mat& dst, double thresh, double maxval, int type)
private static native double threshold_0(long src_nativeObj, long dst_nativeObj, double thresh, double maxval, int type);
// C++: float initWideAngleProjMap(Mat cameraMatrix, Mat distCoeffs, Size imageSize, int destImageWidth, int m1type, Mat& map1, Mat& map2, int projType = PROJ_SPHERICAL_EQRECT, double alpha = 0)
private static native float initWideAngleProjMap_0(long cameraMatrix_nativeObj, long distCoeffs_nativeObj, double imageSize_width, double imageSize_height, int destImageWidth, int m1type, long map1_nativeObj, long map2_nativeObj, int projType, double alpha);
private static native float initWideAngleProjMap_1(long cameraMatrix_nativeObj, long distCoeffs_nativeObj, double imageSize_width, double imageSize_height, int destImageWidth, int m1type, long map1_nativeObj, long map2_nativeObj);
// C++: float intersectConvexConvex(Mat _p1, Mat _p2, Mat& _p12, bool handleNested = true)
private static native float intersectConvexConvex_0(long _p1_nativeObj, long _p2_nativeObj, long _p12_nativeObj, boolean handleNested);
private static native float intersectConvexConvex_1(long _p1_nativeObj, long _p2_nativeObj, long _p12_nativeObj);
// C++: int connectedComponents(Mat image, Mat& labels, int connectivity = 8, int ltype = CV_32S)
private static native int connectedComponents_0(long image_nativeObj, long labels_nativeObj, int connectivity, int ltype);
private static native int connectedComponents_1(long image_nativeObj, long labels_nativeObj);
// C++: int connectedComponentsWithStats(Mat image, Mat& labels, Mat& stats, Mat& centroids, int connectivity = 8, int ltype = CV_32S)
private static native int connectedComponentsWithStats_0(long image_nativeObj, long labels_nativeObj, long stats_nativeObj, long centroids_nativeObj, int connectivity, int ltype);
private static native int connectedComponentsWithStats_1(long image_nativeObj, long labels_nativeObj, long stats_nativeObj, long centroids_nativeObj);
// C++: int floodFill(Mat& image, Mat& mask, Point seedPoint, Scalar newVal, Rect* rect = 0, Scalar loDiff = Scalar(), Scalar upDiff = Scalar(), int flags = 4)
private static native int floodFill_0(long image_nativeObj, long mask_nativeObj, double seedPoint_x, double seedPoint_y, double newVal_val0, double newVal_val1, double newVal_val2, double newVal_val3, double[] rect_out, double loDiff_val0, double loDiff_val1, double loDiff_val2, double loDiff_val3, double upDiff_val0, double upDiff_val1, double upDiff_val2, double upDiff_val3, int flags);
private static native int floodFill_1(long image_nativeObj, long mask_nativeObj, double seedPoint_x, double seedPoint_y, double newVal_val0, double newVal_val1, double newVal_val2, double newVal_val3);
// C++: int rotatedRectangleIntersection(RotatedRect rect1, RotatedRect rect2, Mat& intersectingRegion)
private static native int rotatedRectangleIntersection_0(double rect1_center_x, double rect1_center_y, double rect1_size_width, double rect1_size_height, double rect1_angle, double rect2_center_x, double rect2_center_y, double rect2_size_width, double rect2_size_height, double rect2_angle, long intersectingRegion_nativeObj);
// C++: void Canny(Mat image, Mat& edges, double threshold1, double threshold2, int apertureSize = 3, bool L2gradient = false)
private static native void Canny_0(long image_nativeObj, long edges_nativeObj, double threshold1, double threshold2, int apertureSize, boolean L2gradient);
private static native void Canny_1(long image_nativeObj, long edges_nativeObj, double threshold1, double threshold2);
// C++: void GaussianBlur(Mat src, Mat& dst, Size ksize, double sigmaX, double sigmaY = 0, int borderType = BORDER_DEFAULT)
private static native void GaussianBlur_0(long src_nativeObj, long dst_nativeObj, double ksize_width, double ksize_height, double sigmaX, double sigmaY, int borderType);
private static native void GaussianBlur_1(long src_nativeObj, long dst_nativeObj, double ksize_width, double ksize_height, double sigmaX, double sigmaY);
private static native void GaussianBlur_2(long src_nativeObj, long dst_nativeObj, double ksize_width, double ksize_height, double sigmaX);
// C++: void HoughCircles(Mat image, Mat& circles, int method, double dp, double minDist, double param1 = 100, double param2 = 100, int minRadius = 0, int maxRadius = 0)
private static native void HoughCircles_0(long image_nativeObj, long circles_nativeObj, int method, double dp, double minDist, double param1, double param2, int minRadius, int maxRadius);
private static native void HoughCircles_1(long image_nativeObj, long circles_nativeObj, int method, double dp, double minDist);
// C++: void HoughLines(Mat image, Mat& lines, double rho, double theta, int threshold, double srn = 0, double stn = 0, double min_theta = 0, double max_theta = CV_PI)
private static native void HoughLines_0(long image_nativeObj, long lines_nativeObj, double rho, double theta, int threshold, double srn, double stn, double min_theta, double max_theta);
private static native void HoughLines_1(long image_nativeObj, long lines_nativeObj, double rho, double theta, int threshold);
// C++: void HoughLinesP(Mat image, Mat& lines, double rho, double theta, int threshold, double minLineLength = 0, double maxLineGap = 0)
private static native void HoughLinesP_0(long image_nativeObj, long lines_nativeObj, double rho, double theta, int threshold, double minLineLength, double maxLineGap);
private static native void HoughLinesP_1(long image_nativeObj, long lines_nativeObj, double rho, double theta, int threshold);
// C++: void HuMoments(Moments m, Mat& hu)
private static native void HuMoments_0(double m_m00, double m_m10, double m_m01, double m_m20, double m_m11, double m_m02, double m_m30, double m_m21, double m_m12, double m_m03, long hu_nativeObj);
// C++: void Laplacian(Mat src, Mat& dst, int ddepth, int ksize = 1, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT)
private static native void Laplacian_0(long src_nativeObj, long dst_nativeObj, int ddepth, int ksize, double scale, double delta, int borderType);
private static native void Laplacian_1(long src_nativeObj, long dst_nativeObj, int ddepth, int ksize, double scale, double delta);
private static native void Laplacian_2(long src_nativeObj, long dst_nativeObj, int ddepth);
// C++: void Scharr(Mat src, Mat& dst, int ddepth, int dx, int dy, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT)
private static native void Scharr_0(long src_nativeObj, long dst_nativeObj, int ddepth, int dx, int dy, double scale, double delta, int borderType);
private static native void Scharr_1(long src_nativeObj, long dst_nativeObj, int ddepth, int dx, int dy, double scale, double delta);
private static native void Scharr_2(long src_nativeObj, long dst_nativeObj, int ddepth, int dx, int dy);
// C++: void Sobel(Mat src, Mat& dst, int ddepth, int dx, int dy, int ksize = 3, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT)
private static native void Sobel_0(long src_nativeObj, long dst_nativeObj, int ddepth, int dx, int dy, int ksize, double scale, double delta, int borderType);
private static native void Sobel_1(long src_nativeObj, long dst_nativeObj, int ddepth, int dx, int dy, int ksize, double scale, double delta);
private static native void Sobel_2(long src_nativeObj, long dst_nativeObj, int ddepth, int dx, int dy);
// C++: void accumulate(Mat src, Mat& dst, Mat mask = Mat())
private static native void accumulate_0(long src_nativeObj, long dst_nativeObj, long mask_nativeObj);
private static native void accumulate_1(long src_nativeObj, long dst_nativeObj);
// C++: void accumulateProduct(Mat src1, Mat src2, Mat& dst, Mat mask = Mat())
private static native void accumulateProduct_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, long mask_nativeObj);
private static native void accumulateProduct_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj);
// C++: void accumulateSquare(Mat src, Mat& dst, Mat mask = Mat())
private static native void accumulateSquare_0(long src_nativeObj, long dst_nativeObj, long mask_nativeObj);
private static native void accumulateSquare_1(long src_nativeObj, long dst_nativeObj);
// C++: void accumulateWeighted(Mat src, Mat& dst, double alpha, Mat mask = Mat())
private static native void accumulateWeighted_0(long src_nativeObj, long dst_nativeObj, double alpha, long mask_nativeObj);
private static native void accumulateWeighted_1(long src_nativeObj, long dst_nativeObj, double alpha);
// C++: void adaptiveThreshold(Mat src, Mat& dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C)
private static native void adaptiveThreshold_0(long src_nativeObj, long dst_nativeObj, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C);
// C++: void applyColorMap(Mat src, Mat& dst, int colormap)
private static native void applyColorMap_0(long src_nativeObj, long dst_nativeObj, int colormap);
// C++: void approxPolyDP(vector_Point2f curve, vector_Point2f& approxCurve, double epsilon, bool closed)
private static native void approxPolyDP_0(long curve_mat_nativeObj, long approxCurve_mat_nativeObj, double epsilon, boolean closed);
// C++: void arrowedLine(Mat& img, Point pt1, Point pt2, Scalar color, int thickness = 1, int line_type = 8, int shift = 0, double tipLength = 0.1)
private static native void arrowedLine_0(long img_nativeObj, double pt1_x, double pt1_y, double pt2_x, double pt2_y, double color_val0, double color_val1, double color_val2, double color_val3, int thickness, int line_type, int shift, double tipLength);
private static native void arrowedLine_1(long img_nativeObj, double pt1_x, double pt1_y, double pt2_x, double pt2_y, double color_val0, double color_val1, double color_val2, double color_val3);
// C++: void bilateralFilter(Mat src, Mat& dst, int d, double sigmaColor, double sigmaSpace, int borderType = BORDER_DEFAULT)
private static native void bilateralFilter_0(long src_nativeObj, long dst_nativeObj, int d, double sigmaColor, double sigmaSpace, int borderType);
private static native void bilateralFilter_1(long src_nativeObj, long dst_nativeObj, int d, double sigmaColor, double sigmaSpace);
// C++: void blur(Mat src, Mat& dst, Size ksize, Point anchor = Point(-1,-1), int borderType = BORDER_DEFAULT)
private static native void blur_0(long src_nativeObj, long dst_nativeObj, double ksize_width, double ksize_height, double anchor_x, double anchor_y, int borderType);
private static native void blur_1(long src_nativeObj, long dst_nativeObj, double ksize_width, double ksize_height, double anchor_x, double anchor_y);
private static native void blur_2(long src_nativeObj, long dst_nativeObj, double ksize_width, double ksize_height);
// C++: void boxFilter(Mat src, Mat& dst, int ddepth, Size ksize, Point anchor = Point(-1,-1), bool normalize = true, int borderType = BORDER_DEFAULT)
private static native void boxFilter_0(long src_nativeObj, long dst_nativeObj, int ddepth, double ksize_width, double ksize_height, double anchor_x, double anchor_y, boolean normalize, int borderType);
private static native void boxFilter_1(long src_nativeObj, long dst_nativeObj, int ddepth, double ksize_width, double ksize_height, double anchor_x, double anchor_y, boolean normalize);
private static native void boxFilter_2(long src_nativeObj, long dst_nativeObj, int ddepth, double ksize_width, double ksize_height);
// C++: void boxPoints(RotatedRect box, Mat& points)
private static native void boxPoints_0(double box_center_x, double box_center_y, double box_size_width, double box_size_height, double box_angle, long points_nativeObj);
// C++: void calcBackProject(vector_Mat images, vector_int channels, Mat hist, Mat& dst, vector_float ranges, double scale)
private static native void calcBackProject_0(long images_mat_nativeObj, long channels_mat_nativeObj, long hist_nativeObj, long dst_nativeObj, long ranges_mat_nativeObj, double scale);
// C++: void calcHist(vector_Mat images, vector_int channels, Mat mask, Mat& hist, vector_int histSize, vector_float ranges, bool accumulate = false)
private static native void calcHist_0(long images_mat_nativeObj, long channels_mat_nativeObj, long mask_nativeObj, long hist_nativeObj, long histSize_mat_nativeObj, long ranges_mat_nativeObj, boolean accumulate);
private static native void calcHist_1(long images_mat_nativeObj, long channels_mat_nativeObj, long mask_nativeObj, long hist_nativeObj, long histSize_mat_nativeObj, long ranges_mat_nativeObj);
// C++: void circle(Mat& img, Point center, int radius, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0)
private static native void circle_0(long img_nativeObj, double center_x, double center_y, int radius, double color_val0, double color_val1, double color_val2, double color_val3, int thickness, int lineType, int shift);
private static native void circle_1(long img_nativeObj, double center_x, double center_y, int radius, double color_val0, double color_val1, double color_val2, double color_val3, int thickness);
private static native void circle_2(long img_nativeObj, double center_x, double center_y, int radius, double color_val0, double color_val1, double color_val2, double color_val3);
// C++: void convertMaps(Mat map1, Mat map2, Mat& dstmap1, Mat& dstmap2, int dstmap1type, bool nninterpolation = false)
private static native void convertMaps_0(long map1_nativeObj, long map2_nativeObj, long dstmap1_nativeObj, long dstmap2_nativeObj, int dstmap1type, boolean nninterpolation);
private static native void convertMaps_1(long map1_nativeObj, long map2_nativeObj, long dstmap1_nativeObj, long dstmap2_nativeObj, int dstmap1type);
// C++: void convexHull(vector_Point points, vector_int& hull, bool clockwise = false, _hidden_ returnPoints = true)
private static native void convexHull_0(long points_mat_nativeObj, long hull_mat_nativeObj, boolean clockwise);
private static native void convexHull_1(long points_mat_nativeObj, long hull_mat_nativeObj);
// C++: void convexityDefects(vector_Point contour, vector_int convexhull, vector_Vec4i& convexityDefects)
private static native void convexityDefects_0(long contour_mat_nativeObj, long convexhull_mat_nativeObj, long convexityDefects_mat_nativeObj);
// C++: void cornerEigenValsAndVecs(Mat src, Mat& dst, int blockSize, int ksize, int borderType = BORDER_DEFAULT)
private static native void cornerEigenValsAndVecs_0(long src_nativeObj, long dst_nativeObj, int blockSize, int ksize, int borderType);
private static native void cornerEigenValsAndVecs_1(long src_nativeObj, long dst_nativeObj, int blockSize, int ksize);
// C++: void cornerHarris(Mat src, Mat& dst, int blockSize, int ksize, double k, int borderType = BORDER_DEFAULT)
private static native void cornerHarris_0(long src_nativeObj, long dst_nativeObj, int blockSize, int ksize, double k, int borderType);
private static native void cornerHarris_1(long src_nativeObj, long dst_nativeObj, int blockSize, int ksize, double k);
// C++: void cornerMinEigenVal(Mat src, Mat& dst, int blockSize, int ksize = 3, int borderType = BORDER_DEFAULT)
private static native void cornerMinEigenVal_0(long src_nativeObj, long dst_nativeObj, int blockSize, int ksize, int borderType);
private static native void cornerMinEigenVal_1(long src_nativeObj, long dst_nativeObj, int blockSize, int ksize);
private static native void cornerMinEigenVal_2(long src_nativeObj, long dst_nativeObj, int blockSize);
// C++: void cornerSubPix(Mat image, vector_Point2f& corners, Size winSize, Size zeroZone, TermCriteria criteria)
private static native void cornerSubPix_0(long image_nativeObj, long corners_mat_nativeObj, double winSize_width, double winSize_height, double zeroZone_width, double zeroZone_height, int criteria_type, int criteria_maxCount, double criteria_epsilon);
// C++: void createHanningWindow(Mat& dst, Size winSize, int type)
private static native void createHanningWindow_0(long dst_nativeObj, double winSize_width, double winSize_height, int type);
// C++: void cvtColor(Mat src, Mat& dst, int code, int dstCn = 0)
private static native void cvtColor_0(long src_nativeObj, long dst_nativeObj, int code, int dstCn);
private static native void cvtColor_1(long src_nativeObj, long dst_nativeObj, int code);
// C++: void demosaicing(Mat _src, Mat& _dst, int code, int dcn = 0)
private static native void demosaicing_0(long _src_nativeObj, long _dst_nativeObj, int code, int dcn);
private static native void demosaicing_1(long _src_nativeObj, long _dst_nativeObj, int code);
// C++: void dilate(Mat src, Mat& dst, Mat kernel, Point anchor = Point(-1,-1), int iterations = 1, int borderType = BORDER_CONSTANT, Scalar borderValue = morphologyDefaultBorderValue())
private static native void dilate_0(long src_nativeObj, long dst_nativeObj, long kernel_nativeObj, double anchor_x, double anchor_y, int iterations, int borderType, double borderValue_val0, double borderValue_val1, double borderValue_val2, double borderValue_val3);
private static native void dilate_1(long src_nativeObj, long dst_nativeObj, long kernel_nativeObj, double anchor_x, double anchor_y, int iterations);
private static native void dilate_2(long src_nativeObj, long dst_nativeObj, long kernel_nativeObj);
// C++: void distanceTransform(Mat src, Mat& dst, Mat& labels, int distanceType, int maskSize, int labelType = DIST_LABEL_CCOMP)
private static native void distanceTransformWithLabels_0(long src_nativeObj, long dst_nativeObj, long labels_nativeObj, int distanceType, int maskSize, int labelType);
private static native void distanceTransformWithLabels_1(long src_nativeObj, long dst_nativeObj, long labels_nativeObj, int distanceType, int maskSize);
// C++: void distanceTransform(Mat src, Mat& dst, int distanceType, int maskSize, int dstType = CV_32F)
private static native void distanceTransform_0(long src_nativeObj, long dst_nativeObj, int distanceType, int maskSize, int dstType);
private static native void distanceTransform_1(long src_nativeObj, long dst_nativeObj, int distanceType, int maskSize);
// C++: void drawContours(Mat& image, vector_vector_Point contours, int contourIdx, Scalar color, int thickness = 1, int lineType = LINE_8, Mat hierarchy = Mat(), int maxLevel = INT_MAX, Point offset = Point())
private static native void drawContours_0(long image_nativeObj, long contours_mat_nativeObj, int contourIdx, double color_val0, double color_val1, double color_val2, double color_val3, int thickness, int lineType, long hierarchy_nativeObj, int maxLevel, double offset_x, double offset_y);
private static native void drawContours_1(long image_nativeObj, long contours_mat_nativeObj, int contourIdx, double color_val0, double color_val1, double color_val2, double color_val3, int thickness);
private static native void drawContours_2(long image_nativeObj, long contours_mat_nativeObj, int contourIdx, double color_val0, double color_val1, double color_val2, double color_val3);
// C++: void drawMarker(Mat& img, Point position, Scalar color, int markerType = MARKER_CROSS, int markerSize = 20, int thickness = 1, int line_type = 8)
private static native void drawMarker_0(long img_nativeObj, double position_x, double position_y, double color_val0, double color_val1, double color_val2, double color_val3, int markerType, int markerSize, int thickness, int line_type);
private static native void drawMarker_1(long img_nativeObj, double position_x, double position_y, double color_val0, double color_val1, double color_val2, double color_val3);
// C++: void ellipse(Mat& img, Point center, Size axes, double angle, double startAngle, double endAngle, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0)
private static native void ellipse_0(long img_nativeObj, double center_x, double center_y, double axes_width, double axes_height, double angle, double startAngle, double endAngle, double color_val0, double color_val1, double color_val2, double color_val3, int thickness, int lineType, int shift);
private static native void ellipse_1(long img_nativeObj, double center_x, double center_y, double axes_width, double axes_height, double angle, double startAngle, double endAngle, double color_val0, double color_val1, double color_val2, double color_val3, int thickness);
private static native void ellipse_2(long img_nativeObj, double center_x, double center_y, double axes_width, double axes_height, double angle, double startAngle, double endAngle, double color_val0, double color_val1, double color_val2, double color_val3);
// C++: void ellipse(Mat& img, RotatedRect box, Scalar color, int thickness = 1, int lineType = LINE_8)
private static native void ellipse_3(long img_nativeObj, double box_center_x, double box_center_y, double box_size_width, double box_size_height, double box_angle, double color_val0, double color_val1, double color_val2, double color_val3, int thickness, int lineType);
private static native void ellipse_4(long img_nativeObj, double box_center_x, double box_center_y, double box_size_width, double box_size_height, double box_angle, double color_val0, double color_val1, double color_val2, double color_val3, int thickness);
private static native void ellipse_5(long img_nativeObj, double box_center_x, double box_center_y, double box_size_width, double box_size_height, double box_angle, double color_val0, double color_val1, double color_val2, double color_val3);
// C++: void ellipse2Poly(Point center, Size axes, int angle, int arcStart, int arcEnd, int delta, vector_Point& pts)
private static native void ellipse2Poly_0(double center_x, double center_y, double axes_width, double axes_height, int angle, int arcStart, int arcEnd, int delta, long pts_mat_nativeObj);
// C++: void equalizeHist(Mat src, Mat& dst)
private static native void equalizeHist_0(long src_nativeObj, long dst_nativeObj);
// C++: void erode(Mat src, Mat& dst, Mat kernel, Point anchor = Point(-1,-1), int iterations = 1, int borderType = BORDER_CONSTANT, Scalar borderValue = morphologyDefaultBorderValue())
private static native void erode_0(long src_nativeObj, long dst_nativeObj, long kernel_nativeObj, double anchor_x, double anchor_y, int iterations, int borderType, double borderValue_val0, double borderValue_val1, double borderValue_val2, double borderValue_val3);
private static native void erode_1(long src_nativeObj, long dst_nativeObj, long kernel_nativeObj, double anchor_x, double anchor_y, int iterations);
private static native void erode_2(long src_nativeObj, long dst_nativeObj, long kernel_nativeObj);
// C++: void fillConvexPoly(Mat& img, vector_Point points, Scalar color, int lineType = LINE_8, int shift = 0)
private static native void fillConvexPoly_0(long img_nativeObj, long points_mat_nativeObj, double color_val0, double color_val1, double color_val2, double color_val3, int lineType, int shift);
private static native void fillConvexPoly_1(long img_nativeObj, long points_mat_nativeObj, double color_val0, double color_val1, double color_val2, double color_val3);
// C++: void fillPoly(Mat& img, vector_vector_Point pts, Scalar color, int lineType = LINE_8, int shift = 0, Point offset = Point())
private static native void fillPoly_0(long img_nativeObj, long pts_mat_nativeObj, double color_val0, double color_val1, double color_val2, double color_val3, int lineType, int shift, double offset_x, double offset_y);
private static native void fillPoly_1(long img_nativeObj, long pts_mat_nativeObj, double color_val0, double color_val1, double color_val2, double color_val3);
// C++: void filter2D(Mat src, Mat& dst, int ddepth, Mat kernel, Point anchor = Point(-1,-1), double delta = 0, int borderType = BORDER_DEFAULT)
private static native void filter2D_0(long src_nativeObj, long dst_nativeObj, int ddepth, long kernel_nativeObj, double anchor_x, double anchor_y, double delta, int borderType);
private static native void filter2D_1(long src_nativeObj, long dst_nativeObj, int ddepth, long kernel_nativeObj, double anchor_x, double anchor_y, double delta);
private static native void filter2D_2(long src_nativeObj, long dst_nativeObj, int ddepth, long kernel_nativeObj);
// C++: void findContours(Mat& image, vector_vector_Point& contours, Mat& hierarchy, int mode, int method, Point offset = Point())
private static native void findContours_0(long image_nativeObj, long contours_mat_nativeObj, long hierarchy_nativeObj, int mode, int method, double offset_x, double offset_y);
private static native void findContours_1(long image_nativeObj, long contours_mat_nativeObj, long hierarchy_nativeObj, int mode, int method);
// C++: void fitLine(Mat points, Mat& line, int distType, double param, double reps, double aeps)
private static native void fitLine_0(long points_nativeObj, long line_nativeObj, int distType, double param, double reps, double aeps);
// C++: void getDerivKernels(Mat& kx, Mat& ky, int dx, int dy, int ksize, bool normalize = false, int ktype = CV_32F)
private static native void getDerivKernels_0(long kx_nativeObj, long ky_nativeObj, int dx, int dy, int ksize, boolean normalize, int ktype);
private static native void getDerivKernels_1(long kx_nativeObj, long ky_nativeObj, int dx, int dy, int ksize);
// C++: void getRectSubPix(Mat image, Size patchSize, Point2f center, Mat& patch, int patchType = -1)
private static native void getRectSubPix_0(long image_nativeObj, double patchSize_width, double patchSize_height, double center_x, double center_y, long patch_nativeObj, int patchType);
private static native void getRectSubPix_1(long image_nativeObj, double patchSize_width, double patchSize_height, double center_x, double center_y, long patch_nativeObj);
// C++: void goodFeaturesToTrack(Mat image, vector_Point& corners, int maxCorners, double qualityLevel, double minDistance, Mat mask = Mat(), int blockSize = 3, bool useHarrisDetector = false, double k = 0.04)
private static native void goodFeaturesToTrack_0(long image_nativeObj, long corners_mat_nativeObj, int maxCorners, double qualityLevel, double minDistance, long mask_nativeObj, int blockSize, boolean useHarrisDetector, double k);
private static native void goodFeaturesToTrack_1(long image_nativeObj, long corners_mat_nativeObj, int maxCorners, double qualityLevel, double minDistance);
// C++: void grabCut(Mat img, Mat& mask, Rect rect, Mat& bgdModel, Mat& fgdModel, int iterCount, int mode = GC_EVAL)
private static native void grabCut_0(long img_nativeObj, long mask_nativeObj, int rect_x, int rect_y, int rect_width, int rect_height, long bgdModel_nativeObj, long fgdModel_nativeObj, int iterCount, int mode);
private static native void grabCut_1(long img_nativeObj, long mask_nativeObj, int rect_x, int rect_y, int rect_width, int rect_height, long bgdModel_nativeObj, long fgdModel_nativeObj, int iterCount);
// C++: void initUndistortRectifyMap(Mat cameraMatrix, Mat distCoeffs, Mat R, Mat newCameraMatrix, Size size, int m1type, Mat& map1, Mat& map2)
private static native void initUndistortRectifyMap_0(long cameraMatrix_nativeObj, long distCoeffs_nativeObj, long R_nativeObj, long newCameraMatrix_nativeObj, double size_width, double size_height, int m1type, long map1_nativeObj, long map2_nativeObj);
// C++: void integral(Mat src, Mat& sum, Mat& sqsum, Mat& tilted, int sdepth = -1, int sqdepth = -1)
private static native void integral3_0(long src_nativeObj, long sum_nativeObj, long sqsum_nativeObj, long tilted_nativeObj, int sdepth, int sqdepth);
private static native void integral3_1(long src_nativeObj, long sum_nativeObj, long sqsum_nativeObj, long tilted_nativeObj);
// C++: void integral(Mat src, Mat& sum, Mat& sqsum, int sdepth = -1, int sqdepth = -1)
private static native void integral2_0(long src_nativeObj, long sum_nativeObj, long sqsum_nativeObj, int sdepth, int sqdepth);
private static native void integral2_1(long src_nativeObj, long sum_nativeObj, long sqsum_nativeObj);
// C++: void integral(Mat src, Mat& sum, int sdepth = -1)
private static native void integral_0(long src_nativeObj, long sum_nativeObj, int sdepth);
private static native void integral_1(long src_nativeObj, long sum_nativeObj);
// C++: void invertAffineTransform(Mat M, Mat& iM)
private static native void invertAffineTransform_0(long M_nativeObj, long iM_nativeObj);
// C++: void line(Mat& img, Point pt1, Point pt2, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0)
private static native void line_0(long img_nativeObj, double pt1_x, double pt1_y, double pt2_x, double pt2_y, double color_val0, double color_val1, double color_val2, double color_val3, int thickness, int lineType, int shift);
private static native void line_1(long img_nativeObj, double pt1_x, double pt1_y, double pt2_x, double pt2_y, double color_val0, double color_val1, double color_val2, double color_val3, int thickness);
private static native void line_2(long img_nativeObj, double pt1_x, double pt1_y, double pt2_x, double pt2_y, double color_val0, double color_val1, double color_val2, double color_val3);
// C++: void linearPolar(Mat src, Mat& dst, Point2f center, double maxRadius, int flags)
private static native void linearPolar_0(long src_nativeObj, long dst_nativeObj, double center_x, double center_y, double maxRadius, int flags);
// C++: void logPolar(Mat src, Mat& dst, Point2f center, double M, int flags)
private static native void logPolar_0(long src_nativeObj, long dst_nativeObj, double center_x, double center_y, double M, int flags);
// C++: void matchTemplate(Mat image, Mat templ, Mat& result, int method, Mat mask = Mat())
private static native void matchTemplate_0(long image_nativeObj, long templ_nativeObj, long result_nativeObj, int method, long mask_nativeObj);
private static native void matchTemplate_1(long image_nativeObj, long templ_nativeObj, long result_nativeObj, int method);
// C++: void medianBlur(Mat src, Mat& dst, int ksize)
private static native void medianBlur_0(long src_nativeObj, long dst_nativeObj, int ksize);
// C++: void minEnclosingCircle(vector_Point2f points, Point2f& center, float& radius)
private static native void minEnclosingCircle_0(long points_mat_nativeObj, double[] center_out, double[] radius_out);
// C++: void morphologyEx(Mat src, Mat& dst, int op, Mat kernel, Point anchor = Point(-1,-1), int iterations = 1, int borderType = BORDER_CONSTANT, Scalar borderValue = morphologyDefaultBorderValue())
private static native void morphologyEx_0(long src_nativeObj, long dst_nativeObj, int op, long kernel_nativeObj, double anchor_x, double anchor_y, int iterations, int borderType, double borderValue_val0, double borderValue_val1, double borderValue_val2, double borderValue_val3);
private static native void morphologyEx_1(long src_nativeObj, long dst_nativeObj, int op, long kernel_nativeObj, double anchor_x, double anchor_y, int iterations);
private static native void morphologyEx_2(long src_nativeObj, long dst_nativeObj, int op, long kernel_nativeObj);
// C++: void polylines(Mat& img, vector_vector_Point pts, bool isClosed, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0)
private static native void polylines_0(long img_nativeObj, long pts_mat_nativeObj, boolean isClosed, double color_val0, double color_val1, double color_val2, double color_val3, int thickness, int lineType, int shift);
private static native void polylines_1(long img_nativeObj, long pts_mat_nativeObj, boolean isClosed, double color_val0, double color_val1, double color_val2, double color_val3, int thickness);
private static native void polylines_2(long img_nativeObj, long pts_mat_nativeObj, boolean isClosed, double color_val0, double color_val1, double color_val2, double color_val3);
// C++: void preCornerDetect(Mat src, Mat& dst, int ksize, int borderType = BORDER_DEFAULT)
private static native void preCornerDetect_0(long src_nativeObj, long dst_nativeObj, int ksize, int borderType);
private static native void preCornerDetect_1(long src_nativeObj, long dst_nativeObj, int ksize);
// C++: void putText(Mat& img, String text, Point org, int fontFace, double fontScale, Scalar color, int thickness = 1, int lineType = LINE_8, bool bottomLeftOrigin = false)
private static native void putText_0(long img_nativeObj, String text, double org_x, double org_y, int fontFace, double fontScale, double color_val0, double color_val1, double color_val2, double color_val3, int thickness, int lineType, boolean bottomLeftOrigin);
private static native void putText_1(long img_nativeObj, String text, double org_x, double org_y, int fontFace, double fontScale, double color_val0, double color_val1, double color_val2, double color_val3, int thickness);
private static native void putText_2(long img_nativeObj, String text, double org_x, double org_y, int fontFace, double fontScale, double color_val0, double color_val1, double color_val2, double color_val3);
// C++: void pyrDown(Mat src, Mat& dst, Size dstsize = Size(), int borderType = BORDER_DEFAULT)
private static native void pyrDown_0(long src_nativeObj, long dst_nativeObj, double dstsize_width, double dstsize_height, int borderType);
private static native void pyrDown_1(long src_nativeObj, long dst_nativeObj, double dstsize_width, double dstsize_height);
private static native void pyrDown_2(long src_nativeObj, long dst_nativeObj);
// C++: void pyrMeanShiftFiltering(Mat src, Mat& dst, double sp, double sr, int maxLevel = 1, TermCriteria termcrit = TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS,5,1))
private static native void pyrMeanShiftFiltering_0(long src_nativeObj, long dst_nativeObj, double sp, double sr, int maxLevel, int termcrit_type, int termcrit_maxCount, double termcrit_epsilon);
private static native void pyrMeanShiftFiltering_1(long src_nativeObj, long dst_nativeObj, double sp, double sr);
// C++: void pyrUp(Mat src, Mat& dst, Size dstsize = Size(), int borderType = BORDER_DEFAULT)
private static native void pyrUp_0(long src_nativeObj, long dst_nativeObj, double dstsize_width, double dstsize_height, int borderType);
private static native void pyrUp_1(long src_nativeObj, long dst_nativeObj, double dstsize_width, double dstsize_height);
private static native void pyrUp_2(long src_nativeObj, long dst_nativeObj);
// C++: void rectangle(Mat& img, Point pt1, Point pt2, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0)
private static native void rectangle_0(long img_nativeObj, double pt1_x, double pt1_y, double pt2_x, double pt2_y, double color_val0, double color_val1, double color_val2, double color_val3, int thickness, int lineType, int shift);
private static native void rectangle_1(long img_nativeObj, double pt1_x, double pt1_y, double pt2_x, double pt2_y, double color_val0, double color_val1, double color_val2, double color_val3, int thickness);
private static native void rectangle_2(long img_nativeObj, double pt1_x, double pt1_y, double pt2_x, double pt2_y, double color_val0, double color_val1, double color_val2, double color_val3);
// C++: void remap(Mat src, Mat& dst, Mat map1, Mat map2, int interpolation, int borderMode = BORDER_CONSTANT, Scalar borderValue = Scalar())
private static native void remap_0(long src_nativeObj, long dst_nativeObj, long map1_nativeObj, long map2_nativeObj, int interpolation, int borderMode, double borderValue_val0, double borderValue_val1, double borderValue_val2, double borderValue_val3);
private static native void remap_1(long src_nativeObj, long dst_nativeObj, long map1_nativeObj, long map2_nativeObj, int interpolation);
// C++: void resize(Mat src, Mat& dst, Size dsize, double fx = 0, double fy = 0, int interpolation = INTER_LINEAR)
private static native void resize_0(long src_nativeObj, long dst_nativeObj, double dsize_width, double dsize_height, double fx, double fy, int interpolation);
private static native void resize_1(long src_nativeObj, long dst_nativeObj, double dsize_width, double dsize_height);
// C++: void sepFilter2D(Mat src, Mat& dst, int ddepth, Mat kernelX, Mat kernelY, Point anchor = Point(-1,-1), double delta = 0, int borderType = BORDER_DEFAULT)
private static native void sepFilter2D_0(long src_nativeObj, long dst_nativeObj, int ddepth, long kernelX_nativeObj, long kernelY_nativeObj, double anchor_x, double anchor_y, double delta, int borderType);
private static native void sepFilter2D_1(long src_nativeObj, long dst_nativeObj, int ddepth, long kernelX_nativeObj, long kernelY_nativeObj, double anchor_x, double anchor_y, double delta);
private static native void sepFilter2D_2(long src_nativeObj, long dst_nativeObj, int ddepth, long kernelX_nativeObj, long kernelY_nativeObj);
// C++: void spatialGradient(Mat src, Mat& dx, Mat& dy, int ksize = 3, int borderType = BORDER_DEFAULT)
private static native void spatialGradient_0(long src_nativeObj, long dx_nativeObj, long dy_nativeObj, int ksize, int borderType);
private static native void spatialGradient_1(long src_nativeObj, long dx_nativeObj, long dy_nativeObj, int ksize);
private static native void spatialGradient_2(long src_nativeObj, long dx_nativeObj, long dy_nativeObj);
// C++: void sqrBoxFilter(Mat _src, Mat& _dst, int ddepth, Size ksize, Point anchor = Point(-1, -1), bool normalize = true, int borderType = BORDER_DEFAULT)
private static native void sqrBoxFilter_0(long _src_nativeObj, long _dst_nativeObj, int ddepth, double ksize_width, double ksize_height, double anchor_x, double anchor_y, boolean normalize, int borderType);
private static native void sqrBoxFilter_1(long _src_nativeObj, long _dst_nativeObj, int ddepth, double ksize_width, double ksize_height, double anchor_x, double anchor_y, boolean normalize);
private static native void sqrBoxFilter_2(long _src_nativeObj, long _dst_nativeObj, int ddepth, double ksize_width, double ksize_height);
// C++: void undistort(Mat src, Mat& dst, Mat cameraMatrix, Mat distCoeffs, Mat newCameraMatrix = Mat())
private static native void undistort_0(long src_nativeObj, long dst_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_nativeObj, long newCameraMatrix_nativeObj);
private static native void undistort_1(long src_nativeObj, long dst_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_nativeObj);
// C++: void undistortPoints(vector_Point2f src, vector_Point2f& dst, Mat cameraMatrix, Mat distCoeffs, Mat R = Mat(), Mat P = Mat())
private static native void undistortPoints_0(long src_mat_nativeObj, long dst_mat_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_nativeObj, long R_nativeObj, long P_nativeObj);
private static native void undistortPoints_1(long src_mat_nativeObj, long dst_mat_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_nativeObj);
// C++: void warpAffine(Mat src, Mat& dst, Mat M, Size dsize, int flags = INTER_LINEAR, int borderMode = BORDER_CONSTANT, Scalar borderValue = Scalar())
private static native void warpAffine_0(long src_nativeObj, long dst_nativeObj, long M_nativeObj, double dsize_width, double dsize_height, int flags, int borderMode, double borderValue_val0, double borderValue_val1, double borderValue_val2, double borderValue_val3);
private static native void warpAffine_1(long src_nativeObj, long dst_nativeObj, long M_nativeObj, double dsize_width, double dsize_height, int flags);
private static native void warpAffine_2(long src_nativeObj, long dst_nativeObj, long M_nativeObj, double dsize_width, double dsize_height);
// C++: void warpPerspective(Mat src, Mat& dst, Mat M, Size dsize, int flags = INTER_LINEAR, int borderMode = BORDER_CONSTANT, Scalar borderValue = Scalar())
private static native void warpPerspective_0(long src_nativeObj, long dst_nativeObj, long M_nativeObj, double dsize_width, double dsize_height, int flags, int borderMode, double borderValue_val0, double borderValue_val1, double borderValue_val2, double borderValue_val3);
private static native void warpPerspective_1(long src_nativeObj, long dst_nativeObj, long M_nativeObj, double dsize_width, double dsize_height, int flags);
private static native void warpPerspective_2(long src_nativeObj, long dst_nativeObj, long M_nativeObj, double dsize_width, double dsize_height);
// C++: void watershed(Mat image, Mat& markers)
private static native void watershed_0(long image_nativeObj, long markers_nativeObj);
private static native double[] n_getTextSize(String text, int fontFace, double fontScale, int thickness, int[] baseLine);
}
| 147,709 | 42.533746 | 395 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/imgproc/CLAHE.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.imgproc;
import org.opencv.core.Algorithm;
import org.opencv.core.Mat;
import org.opencv.core.Size;
// C++: class CLAHE
//javadoc: CLAHE
public class CLAHE extends Algorithm {
protected CLAHE(long addr) { super(addr); }
//
// C++: Size getTilesGridSize()
//
//javadoc: CLAHE::getTilesGridSize()
public Size getTilesGridSize()
{
Size retVal = new Size(getTilesGridSize_0(nativeObj));
return retVal;
}
//
// C++: double getClipLimit()
//
//javadoc: CLAHE::getClipLimit()
public double getClipLimit()
{
double retVal = getClipLimit_0(nativeObj);
return retVal;
}
//
// C++: void apply(Mat src, Mat& dst)
//
//javadoc: CLAHE::apply(src, dst)
public void apply(Mat src, Mat dst)
{
apply_0(nativeObj, src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void collectGarbage()
//
//javadoc: CLAHE::collectGarbage()
public void collectGarbage()
{
collectGarbage_0(nativeObj);
return;
}
//
// C++: void setClipLimit(double clipLimit)
//
//javadoc: CLAHE::setClipLimit(clipLimit)
public void setClipLimit(double clipLimit)
{
setClipLimit_0(nativeObj, clipLimit);
return;
}
//
// C++: void setTilesGridSize(Size tileGridSize)
//
//javadoc: CLAHE::setTilesGridSize(tileGridSize)
public void setTilesGridSize(Size tileGridSize)
{
setTilesGridSize_0(nativeObj, tileGridSize.width, tileGridSize.height);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: Size getTilesGridSize()
private static native double[] getTilesGridSize_0(long nativeObj);
// C++: double getClipLimit()
private static native double getClipLimit_0(long nativeObj);
// C++: void apply(Mat src, Mat& dst)
private static native void apply_0(long nativeObj, long src_nativeObj, long dst_nativeObj);
// C++: void collectGarbage()
private static native void collectGarbage_0(long nativeObj);
// C++: void setClipLimit(double clipLimit)
private static native void setClipLimit_0(long nativeObj, double clipLimit);
// C++: void setTilesGridSize(Size tileGridSize)
private static native void setTilesGridSize_0(long nativeObj, double tileGridSize_width, double tileGridSize_height);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 2,749 | 19.992366 | 121 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/photo/AlignMTB.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.photo;
import java.util.ArrayList;
import java.util.List;
import org.opencv.core.Mat;
import org.opencv.core.Point;
import org.opencv.utils.Converters;
// C++: class AlignMTB
//javadoc: AlignMTB
public class AlignMTB extends AlignExposures {
protected AlignMTB(long addr) { super(addr); }
//
// C++: Point calculateShift(Mat img0, Mat img1)
//
//javadoc: AlignMTB::calculateShift(img0, img1)
public Point calculateShift(Mat img0, Mat img1)
{
Point retVal = new Point(calculateShift_0(nativeObj, img0.nativeObj, img1.nativeObj));
return retVal;
}
//
// C++: bool getCut()
//
//javadoc: AlignMTB::getCut()
public boolean getCut()
{
boolean retVal = getCut_0(nativeObj);
return retVal;
}
//
// C++: int getExcludeRange()
//
//javadoc: AlignMTB::getExcludeRange()
public int getExcludeRange()
{
int retVal = getExcludeRange_0(nativeObj);
return retVal;
}
//
// C++: int getMaxBits()
//
//javadoc: AlignMTB::getMaxBits()
public int getMaxBits()
{
int retVal = getMaxBits_0(nativeObj);
return retVal;
}
//
// C++: void computeBitmaps(Mat img, Mat& tb, Mat& eb)
//
//javadoc: AlignMTB::computeBitmaps(img, tb, eb)
public void computeBitmaps(Mat img, Mat tb, Mat eb)
{
computeBitmaps_0(nativeObj, img.nativeObj, tb.nativeObj, eb.nativeObj);
return;
}
//
// C++: void process(vector_Mat src, vector_Mat dst, Mat times, Mat response)
//
//javadoc: AlignMTB::process(src, dst, times, response)
public void process(List<Mat> src, List<Mat> dst, Mat times, Mat response)
{
Mat src_mat = Converters.vector_Mat_to_Mat(src);
Mat dst_mat = Converters.vector_Mat_to_Mat(dst);
process_0(nativeObj, src_mat.nativeObj, dst_mat.nativeObj, times.nativeObj, response.nativeObj);
return;
}
//
// C++: void process(vector_Mat src, vector_Mat dst)
//
//javadoc: AlignMTB::process(src, dst)
public void process(List<Mat> src, List<Mat> dst)
{
Mat src_mat = Converters.vector_Mat_to_Mat(src);
Mat dst_mat = Converters.vector_Mat_to_Mat(dst);
process_1(nativeObj, src_mat.nativeObj, dst_mat.nativeObj);
return;
}
//
// C++: void setCut(bool value)
//
//javadoc: AlignMTB::setCut(value)
public void setCut(boolean value)
{
setCut_0(nativeObj, value);
return;
}
//
// C++: void setExcludeRange(int exclude_range)
//
//javadoc: AlignMTB::setExcludeRange(exclude_range)
public void setExcludeRange(int exclude_range)
{
setExcludeRange_0(nativeObj, exclude_range);
return;
}
//
// C++: void setMaxBits(int max_bits)
//
//javadoc: AlignMTB::setMaxBits(max_bits)
public void setMaxBits(int max_bits)
{
setMaxBits_0(nativeObj, max_bits);
return;
}
//
// C++: void shiftMat(Mat src, Mat& dst, Point shift)
//
//javadoc: AlignMTB::shiftMat(src, dst, shift)
public void shiftMat(Mat src, Mat dst, Point shift)
{
shiftMat_0(nativeObj, src.nativeObj, dst.nativeObj, shift.x, shift.y);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: Point calculateShift(Mat img0, Mat img1)
private static native double[] calculateShift_0(long nativeObj, long img0_nativeObj, long img1_nativeObj);
// C++: bool getCut()
private static native boolean getCut_0(long nativeObj);
// C++: int getExcludeRange()
private static native int getExcludeRange_0(long nativeObj);
// C++: int getMaxBits()
private static native int getMaxBits_0(long nativeObj);
// C++: void computeBitmaps(Mat img, Mat& tb, Mat& eb)
private static native void computeBitmaps_0(long nativeObj, long img_nativeObj, long tb_nativeObj, long eb_nativeObj);
// C++: void process(vector_Mat src, vector_Mat dst, Mat times, Mat response)
private static native void process_0(long nativeObj, long src_mat_nativeObj, long dst_mat_nativeObj, long times_nativeObj, long response_nativeObj);
// C++: void process(vector_Mat src, vector_Mat dst)
private static native void process_1(long nativeObj, long src_mat_nativeObj, long dst_mat_nativeObj);
// C++: void setCut(bool value)
private static native void setCut_0(long nativeObj, boolean value);
// C++: void setExcludeRange(int exclude_range)
private static native void setExcludeRange_0(long nativeObj, int exclude_range);
// C++: void setMaxBits(int max_bits)
private static native void setMaxBits_0(long nativeObj, int max_bits);
// C++: void shiftMat(Mat src, Mat& dst, Point shift)
private static native void shiftMat_0(long nativeObj, long src_nativeObj, long dst_nativeObj, double shift_x, double shift_y);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 5,384 | 23.477273 | 152 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/photo/Photo.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.photo;
import java.util.ArrayList;
import java.util.List;
import org.opencv.core.Mat;
import org.opencv.core.MatOfFloat;
import org.opencv.core.Point;
import org.opencv.utils.Converters;
public class Photo {
private static final int
CV_INPAINT_NS = 0,
CV_INPAINT_TELEA = 1;
public static final int
INPAINT_NS = 0,
INPAINT_TELEA = 1,
NORMAL_CLONE = 1,
MIXED_CLONE = 2,
MONOCHROME_TRANSFER = 3,
RECURS_FILTER = 1,
NORMCONV_FILTER = 2,
LDR_SIZE = 256;
//
// C++: Ptr_AlignMTB createAlignMTB(int max_bits = 6, int exclude_range = 4, bool cut = true)
//
//javadoc: createAlignMTB(max_bits, exclude_range, cut)
public static AlignMTB createAlignMTB(int max_bits, int exclude_range, boolean cut)
{
AlignMTB retVal = new AlignMTB(createAlignMTB_0(max_bits, exclude_range, cut));
return retVal;
}
//javadoc: createAlignMTB()
public static AlignMTB createAlignMTB()
{
AlignMTB retVal = new AlignMTB(createAlignMTB_1());
return retVal;
}
//
// C++: Ptr_CalibrateDebevec createCalibrateDebevec(int samples = 70, float lambda = 10.0f, bool random = false)
//
//javadoc: createCalibrateDebevec(samples, lambda, random)
public static CalibrateDebevec createCalibrateDebevec(int samples, float lambda, boolean random)
{
CalibrateDebevec retVal = new CalibrateDebevec(createCalibrateDebevec_0(samples, lambda, random));
return retVal;
}
//javadoc: createCalibrateDebevec()
public static CalibrateDebevec createCalibrateDebevec()
{
CalibrateDebevec retVal = new CalibrateDebevec(createCalibrateDebevec_1());
return retVal;
}
//
// C++: Ptr_CalibrateRobertson createCalibrateRobertson(int max_iter = 30, float threshold = 0.01f)
//
//javadoc: createCalibrateRobertson(max_iter, threshold)
public static CalibrateRobertson createCalibrateRobertson(int max_iter, float threshold)
{
CalibrateRobertson retVal = new CalibrateRobertson(createCalibrateRobertson_0(max_iter, threshold));
return retVal;
}
//javadoc: createCalibrateRobertson()
public static CalibrateRobertson createCalibrateRobertson()
{
CalibrateRobertson retVal = new CalibrateRobertson(createCalibrateRobertson_1());
return retVal;
}
//
// C++: Ptr_MergeDebevec createMergeDebevec()
//
//javadoc: createMergeDebevec()
public static MergeDebevec createMergeDebevec()
{
MergeDebevec retVal = new MergeDebevec(createMergeDebevec_0());
return retVal;
}
//
// C++: Ptr_MergeMertens createMergeMertens(float contrast_weight = 1.0f, float saturation_weight = 1.0f, float exposure_weight = 0.0f)
//
//javadoc: createMergeMertens(contrast_weight, saturation_weight, exposure_weight)
public static MergeMertens createMergeMertens(float contrast_weight, float saturation_weight, float exposure_weight)
{
MergeMertens retVal = new MergeMertens(createMergeMertens_0(contrast_weight, saturation_weight, exposure_weight));
return retVal;
}
//javadoc: createMergeMertens()
public static MergeMertens createMergeMertens()
{
MergeMertens retVal = new MergeMertens(createMergeMertens_1());
return retVal;
}
//
// C++: Ptr_MergeRobertson createMergeRobertson()
//
//javadoc: createMergeRobertson()
public static MergeRobertson createMergeRobertson()
{
MergeRobertson retVal = new MergeRobertson(createMergeRobertson_0());
return retVal;
}
//
// C++: Ptr_Tonemap createTonemap(float gamma = 1.0f)
//
//javadoc: createTonemap(gamma)
public static Tonemap createTonemap(float gamma)
{
Tonemap retVal = new Tonemap(createTonemap_0(gamma));
return retVal;
}
//javadoc: createTonemap()
public static Tonemap createTonemap()
{
Tonemap retVal = new Tonemap(createTonemap_1());
return retVal;
}
//
// C++: Ptr_TonemapDrago createTonemapDrago(float gamma = 1.0f, float saturation = 1.0f, float bias = 0.85f)
//
//javadoc: createTonemapDrago(gamma, saturation, bias)
public static TonemapDrago createTonemapDrago(float gamma, float saturation, float bias)
{
TonemapDrago retVal = new TonemapDrago(createTonemapDrago_0(gamma, saturation, bias));
return retVal;
}
//javadoc: createTonemapDrago()
public static TonemapDrago createTonemapDrago()
{
TonemapDrago retVal = new TonemapDrago(createTonemapDrago_1());
return retVal;
}
//
// C++: Ptr_TonemapDurand createTonemapDurand(float gamma = 1.0f, float contrast = 4.0f, float saturation = 1.0f, float sigma_space = 2.0f, float sigma_color = 2.0f)
//
//javadoc: createTonemapDurand(gamma, contrast, saturation, sigma_space, sigma_color)
public static TonemapDurand createTonemapDurand(float gamma, float contrast, float saturation, float sigma_space, float sigma_color)
{
TonemapDurand retVal = new TonemapDurand(createTonemapDurand_0(gamma, contrast, saturation, sigma_space, sigma_color));
return retVal;
}
//javadoc: createTonemapDurand()
public static TonemapDurand createTonemapDurand()
{
TonemapDurand retVal = new TonemapDurand(createTonemapDurand_1());
return retVal;
}
//
// C++: Ptr_TonemapMantiuk createTonemapMantiuk(float gamma = 1.0f, float scale = 0.7f, float saturation = 1.0f)
//
//javadoc: createTonemapMantiuk(gamma, scale, saturation)
public static TonemapMantiuk createTonemapMantiuk(float gamma, float scale, float saturation)
{
TonemapMantiuk retVal = new TonemapMantiuk(createTonemapMantiuk_0(gamma, scale, saturation));
return retVal;
}
//javadoc: createTonemapMantiuk()
public static TonemapMantiuk createTonemapMantiuk()
{
TonemapMantiuk retVal = new TonemapMantiuk(createTonemapMantiuk_1());
return retVal;
}
//
// C++: Ptr_TonemapReinhard createTonemapReinhard(float gamma = 1.0f, float intensity = 0.0f, float light_adapt = 1.0f, float color_adapt = 0.0f)
//
//javadoc: createTonemapReinhard(gamma, intensity, light_adapt, color_adapt)
public static TonemapReinhard createTonemapReinhard(float gamma, float intensity, float light_adapt, float color_adapt)
{
TonemapReinhard retVal = new TonemapReinhard(createTonemapReinhard_0(gamma, intensity, light_adapt, color_adapt));
return retVal;
}
//javadoc: createTonemapReinhard()
public static TonemapReinhard createTonemapReinhard()
{
TonemapReinhard retVal = new TonemapReinhard(createTonemapReinhard_1());
return retVal;
}
//
// C++: void colorChange(Mat src, Mat mask, Mat& dst, float red_mul = 1.0f, float green_mul = 1.0f, float blue_mul = 1.0f)
//
//javadoc: colorChange(src, mask, dst, red_mul, green_mul, blue_mul)
public static void colorChange(Mat src, Mat mask, Mat dst, float red_mul, float green_mul, float blue_mul)
{
colorChange_0(src.nativeObj, mask.nativeObj, dst.nativeObj, red_mul, green_mul, blue_mul);
return;
}
//javadoc: colorChange(src, mask, dst)
public static void colorChange(Mat src, Mat mask, Mat dst)
{
colorChange_1(src.nativeObj, mask.nativeObj, dst.nativeObj);
return;
}
//
// C++: void decolor(Mat src, Mat& grayscale, Mat& color_boost)
//
//javadoc: decolor(src, grayscale, color_boost)
public static void decolor(Mat src, Mat grayscale, Mat color_boost)
{
decolor_0(src.nativeObj, grayscale.nativeObj, color_boost.nativeObj);
return;
}
//
// C++: void denoise_TVL1(vector_Mat observations, Mat result, double lambda = 1.0, int niters = 30)
//
//javadoc: denoise_TVL1(observations, result, lambda, niters)
public static void denoise_TVL1(List<Mat> observations, Mat result, double lambda, int niters)
{
Mat observations_mat = Converters.vector_Mat_to_Mat(observations);
denoise_TVL1_0(observations_mat.nativeObj, result.nativeObj, lambda, niters);
return;
}
//javadoc: denoise_TVL1(observations, result)
public static void denoise_TVL1(List<Mat> observations, Mat result)
{
Mat observations_mat = Converters.vector_Mat_to_Mat(observations);
denoise_TVL1_1(observations_mat.nativeObj, result.nativeObj);
return;
}
//
// C++: void detailEnhance(Mat src, Mat& dst, float sigma_s = 10, float sigma_r = 0.15f)
//
//javadoc: detailEnhance(src, dst, sigma_s, sigma_r)
public static void detailEnhance(Mat src, Mat dst, float sigma_s, float sigma_r)
{
detailEnhance_0(src.nativeObj, dst.nativeObj, sigma_s, sigma_r);
return;
}
//javadoc: detailEnhance(src, dst)
public static void detailEnhance(Mat src, Mat dst)
{
detailEnhance_1(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void edgePreservingFilter(Mat src, Mat& dst, int flags = 1, float sigma_s = 60, float sigma_r = 0.4f)
//
//javadoc: edgePreservingFilter(src, dst, flags, sigma_s, sigma_r)
public static void edgePreservingFilter(Mat src, Mat dst, int flags, float sigma_s, float sigma_r)
{
edgePreservingFilter_0(src.nativeObj, dst.nativeObj, flags, sigma_s, sigma_r);
return;
}
//javadoc: edgePreservingFilter(src, dst)
public static void edgePreservingFilter(Mat src, Mat dst)
{
edgePreservingFilter_1(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void fastNlMeansDenoising(Mat src, Mat& dst, float h = 3, int templateWindowSize = 7, int searchWindowSize = 21)
//
//javadoc: fastNlMeansDenoising(src, dst, h, templateWindowSize, searchWindowSize)
public static void fastNlMeansDenoising(Mat src, Mat dst, float h, int templateWindowSize, int searchWindowSize)
{
fastNlMeansDenoising_0(src.nativeObj, dst.nativeObj, h, templateWindowSize, searchWindowSize);
return;
}
//javadoc: fastNlMeansDenoising(src, dst)
public static void fastNlMeansDenoising(Mat src, Mat dst)
{
fastNlMeansDenoising_1(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void fastNlMeansDenoising(Mat src, Mat& dst, vector_float h, int templateWindowSize = 7, int searchWindowSize = 21, int normType = NORM_L2)
//
//javadoc: fastNlMeansDenoising(src, dst, h, templateWindowSize, searchWindowSize, normType)
public static void fastNlMeansDenoising(Mat src, Mat dst, MatOfFloat h, int templateWindowSize, int searchWindowSize, int normType)
{
Mat h_mat = h;
fastNlMeansDenoising_2(src.nativeObj, dst.nativeObj, h_mat.nativeObj, templateWindowSize, searchWindowSize, normType);
return;
}
//javadoc: fastNlMeansDenoising(src, dst, h)
public static void fastNlMeansDenoising(Mat src, Mat dst, MatOfFloat h)
{
Mat h_mat = h;
fastNlMeansDenoising_3(src.nativeObj, dst.nativeObj, h_mat.nativeObj);
return;
}
//
// C++: void fastNlMeansDenoisingColored(Mat src, Mat& dst, float h = 3, float hColor = 3, int templateWindowSize = 7, int searchWindowSize = 21)
//
//javadoc: fastNlMeansDenoisingColored(src, dst, h, hColor, templateWindowSize, searchWindowSize)
public static void fastNlMeansDenoisingColored(Mat src, Mat dst, float h, float hColor, int templateWindowSize, int searchWindowSize)
{
fastNlMeansDenoisingColored_0(src.nativeObj, dst.nativeObj, h, hColor, templateWindowSize, searchWindowSize);
return;
}
//javadoc: fastNlMeansDenoisingColored(src, dst)
public static void fastNlMeansDenoisingColored(Mat src, Mat dst)
{
fastNlMeansDenoisingColored_1(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void fastNlMeansDenoisingColoredMulti(vector_Mat srcImgs, Mat& dst, int imgToDenoiseIndex, int temporalWindowSize, float h = 3, float hColor = 3, int templateWindowSize = 7, int searchWindowSize = 21)
//
//javadoc: fastNlMeansDenoisingColoredMulti(srcImgs, dst, imgToDenoiseIndex, temporalWindowSize, h, hColor, templateWindowSize, searchWindowSize)
public static void fastNlMeansDenoisingColoredMulti(List<Mat> srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize)
{
Mat srcImgs_mat = Converters.vector_Mat_to_Mat(srcImgs);
fastNlMeansDenoisingColoredMulti_0(srcImgs_mat.nativeObj, dst.nativeObj, imgToDenoiseIndex, temporalWindowSize, h, hColor, templateWindowSize, searchWindowSize);
return;
}
//javadoc: fastNlMeansDenoisingColoredMulti(srcImgs, dst, imgToDenoiseIndex, temporalWindowSize)
public static void fastNlMeansDenoisingColoredMulti(List<Mat> srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize)
{
Mat srcImgs_mat = Converters.vector_Mat_to_Mat(srcImgs);
fastNlMeansDenoisingColoredMulti_1(srcImgs_mat.nativeObj, dst.nativeObj, imgToDenoiseIndex, temporalWindowSize);
return;
}
//
// C++: void fastNlMeansDenoisingMulti(vector_Mat srcImgs, Mat& dst, int imgToDenoiseIndex, int temporalWindowSize, float h = 3, int templateWindowSize = 7, int searchWindowSize = 21)
//
//javadoc: fastNlMeansDenoisingMulti(srcImgs, dst, imgToDenoiseIndex, temporalWindowSize, h, templateWindowSize, searchWindowSize)
public static void fastNlMeansDenoisingMulti(List<Mat> srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize)
{
Mat srcImgs_mat = Converters.vector_Mat_to_Mat(srcImgs);
fastNlMeansDenoisingMulti_0(srcImgs_mat.nativeObj, dst.nativeObj, imgToDenoiseIndex, temporalWindowSize, h, templateWindowSize, searchWindowSize);
return;
}
//javadoc: fastNlMeansDenoisingMulti(srcImgs, dst, imgToDenoiseIndex, temporalWindowSize)
public static void fastNlMeansDenoisingMulti(List<Mat> srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize)
{
Mat srcImgs_mat = Converters.vector_Mat_to_Mat(srcImgs);
fastNlMeansDenoisingMulti_1(srcImgs_mat.nativeObj, dst.nativeObj, imgToDenoiseIndex, temporalWindowSize);
return;
}
//
// C++: void fastNlMeansDenoisingMulti(vector_Mat srcImgs, Mat& dst, int imgToDenoiseIndex, int temporalWindowSize, vector_float h, int templateWindowSize = 7, int searchWindowSize = 21, int normType = NORM_L2)
//
//javadoc: fastNlMeansDenoisingMulti(srcImgs, dst, imgToDenoiseIndex, temporalWindowSize, h, templateWindowSize, searchWindowSize, normType)
public static void fastNlMeansDenoisingMulti(List<Mat> srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, MatOfFloat h, int templateWindowSize, int searchWindowSize, int normType)
{
Mat srcImgs_mat = Converters.vector_Mat_to_Mat(srcImgs);
Mat h_mat = h;
fastNlMeansDenoisingMulti_2(srcImgs_mat.nativeObj, dst.nativeObj, imgToDenoiseIndex, temporalWindowSize, h_mat.nativeObj, templateWindowSize, searchWindowSize, normType);
return;
}
//javadoc: fastNlMeansDenoisingMulti(srcImgs, dst, imgToDenoiseIndex, temporalWindowSize, h)
public static void fastNlMeansDenoisingMulti(List<Mat> srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, MatOfFloat h)
{
Mat srcImgs_mat = Converters.vector_Mat_to_Mat(srcImgs);
Mat h_mat = h;
fastNlMeansDenoisingMulti_3(srcImgs_mat.nativeObj, dst.nativeObj, imgToDenoiseIndex, temporalWindowSize, h_mat.nativeObj);
return;
}
//
// C++: void illuminationChange(Mat src, Mat mask, Mat& dst, float alpha = 0.2f, float beta = 0.4f)
//
//javadoc: illuminationChange(src, mask, dst, alpha, beta)
public static void illuminationChange(Mat src, Mat mask, Mat dst, float alpha, float beta)
{
illuminationChange_0(src.nativeObj, mask.nativeObj, dst.nativeObj, alpha, beta);
return;
}
//javadoc: illuminationChange(src, mask, dst)
public static void illuminationChange(Mat src, Mat mask, Mat dst)
{
illuminationChange_1(src.nativeObj, mask.nativeObj, dst.nativeObj);
return;
}
//
// C++: void inpaint(Mat src, Mat inpaintMask, Mat& dst, double inpaintRadius, int flags)
//
//javadoc: inpaint(src, inpaintMask, dst, inpaintRadius, flags)
public static void inpaint(Mat src, Mat inpaintMask, Mat dst, double inpaintRadius, int flags)
{
inpaint_0(src.nativeObj, inpaintMask.nativeObj, dst.nativeObj, inpaintRadius, flags);
return;
}
//
// C++: void pencilSketch(Mat src, Mat& dst1, Mat& dst2, float sigma_s = 60, float sigma_r = 0.07f, float shade_factor = 0.02f)
//
//javadoc: pencilSketch(src, dst1, dst2, sigma_s, sigma_r, shade_factor)
public static void pencilSketch(Mat src, Mat dst1, Mat dst2, float sigma_s, float sigma_r, float shade_factor)
{
pencilSketch_0(src.nativeObj, dst1.nativeObj, dst2.nativeObj, sigma_s, sigma_r, shade_factor);
return;
}
//javadoc: pencilSketch(src, dst1, dst2)
public static void pencilSketch(Mat src, Mat dst1, Mat dst2)
{
pencilSketch_1(src.nativeObj, dst1.nativeObj, dst2.nativeObj);
return;
}
//
// C++: void seamlessClone(Mat src, Mat dst, Mat mask, Point p, Mat& blend, int flags)
//
//javadoc: seamlessClone(src, dst, mask, p, blend, flags)
public static void seamlessClone(Mat src, Mat dst, Mat mask, Point p, Mat blend, int flags)
{
seamlessClone_0(src.nativeObj, dst.nativeObj, mask.nativeObj, p.x, p.y, blend.nativeObj, flags);
return;
}
//
// C++: void stylization(Mat src, Mat& dst, float sigma_s = 60, float sigma_r = 0.45f)
//
//javadoc: stylization(src, dst, sigma_s, sigma_r)
public static void stylization(Mat src, Mat dst, float sigma_s, float sigma_r)
{
stylization_0(src.nativeObj, dst.nativeObj, sigma_s, sigma_r);
return;
}
//javadoc: stylization(src, dst)
public static void stylization(Mat src, Mat dst)
{
stylization_1(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void textureFlattening(Mat src, Mat mask, Mat& dst, float low_threshold = 30, float high_threshold = 45, int kernel_size = 3)
//
//javadoc: textureFlattening(src, mask, dst, low_threshold, high_threshold, kernel_size)
public static void textureFlattening(Mat src, Mat mask, Mat dst, float low_threshold, float high_threshold, int kernel_size)
{
textureFlattening_0(src.nativeObj, mask.nativeObj, dst.nativeObj, low_threshold, high_threshold, kernel_size);
return;
}
//javadoc: textureFlattening(src, mask, dst)
public static void textureFlattening(Mat src, Mat mask, Mat dst)
{
textureFlattening_1(src.nativeObj, mask.nativeObj, dst.nativeObj);
return;
}
// C++: Ptr_AlignMTB createAlignMTB(int max_bits = 6, int exclude_range = 4, bool cut = true)
private static native long createAlignMTB_0(int max_bits, int exclude_range, boolean cut);
private static native long createAlignMTB_1();
// C++: Ptr_CalibrateDebevec createCalibrateDebevec(int samples = 70, float lambda = 10.0f, bool random = false)
private static native long createCalibrateDebevec_0(int samples, float lambda, boolean random);
private static native long createCalibrateDebevec_1();
// C++: Ptr_CalibrateRobertson createCalibrateRobertson(int max_iter = 30, float threshold = 0.01f)
private static native long createCalibrateRobertson_0(int max_iter, float threshold);
private static native long createCalibrateRobertson_1();
// C++: Ptr_MergeDebevec createMergeDebevec()
private static native long createMergeDebevec_0();
// C++: Ptr_MergeMertens createMergeMertens(float contrast_weight = 1.0f, float saturation_weight = 1.0f, float exposure_weight = 0.0f)
private static native long createMergeMertens_0(float contrast_weight, float saturation_weight, float exposure_weight);
private static native long createMergeMertens_1();
// C++: Ptr_MergeRobertson createMergeRobertson()
private static native long createMergeRobertson_0();
// C++: Ptr_Tonemap createTonemap(float gamma = 1.0f)
private static native long createTonemap_0(float gamma);
private static native long createTonemap_1();
// C++: Ptr_TonemapDrago createTonemapDrago(float gamma = 1.0f, float saturation = 1.0f, float bias = 0.85f)
private static native long createTonemapDrago_0(float gamma, float saturation, float bias);
private static native long createTonemapDrago_1();
// C++: Ptr_TonemapDurand createTonemapDurand(float gamma = 1.0f, float contrast = 4.0f, float saturation = 1.0f, float sigma_space = 2.0f, float sigma_color = 2.0f)
private static native long createTonemapDurand_0(float gamma, float contrast, float saturation, float sigma_space, float sigma_color);
private static native long createTonemapDurand_1();
// C++: Ptr_TonemapMantiuk createTonemapMantiuk(float gamma = 1.0f, float scale = 0.7f, float saturation = 1.0f)
private static native long createTonemapMantiuk_0(float gamma, float scale, float saturation);
private static native long createTonemapMantiuk_1();
// C++: Ptr_TonemapReinhard createTonemapReinhard(float gamma = 1.0f, float intensity = 0.0f, float light_adapt = 1.0f, float color_adapt = 0.0f)
private static native long createTonemapReinhard_0(float gamma, float intensity, float light_adapt, float color_adapt);
private static native long createTonemapReinhard_1();
// C++: void colorChange(Mat src, Mat mask, Mat& dst, float red_mul = 1.0f, float green_mul = 1.0f, float blue_mul = 1.0f)
private static native void colorChange_0(long src_nativeObj, long mask_nativeObj, long dst_nativeObj, float red_mul, float green_mul, float blue_mul);
private static native void colorChange_1(long src_nativeObj, long mask_nativeObj, long dst_nativeObj);
// C++: void decolor(Mat src, Mat& grayscale, Mat& color_boost)
private static native void decolor_0(long src_nativeObj, long grayscale_nativeObj, long color_boost_nativeObj);
// C++: void denoise_TVL1(vector_Mat observations, Mat result, double lambda = 1.0, int niters = 30)
private static native void denoise_TVL1_0(long observations_mat_nativeObj, long result_nativeObj, double lambda, int niters);
private static native void denoise_TVL1_1(long observations_mat_nativeObj, long result_nativeObj);
// C++: void detailEnhance(Mat src, Mat& dst, float sigma_s = 10, float sigma_r = 0.15f)
private static native void detailEnhance_0(long src_nativeObj, long dst_nativeObj, float sigma_s, float sigma_r);
private static native void detailEnhance_1(long src_nativeObj, long dst_nativeObj);
// C++: void edgePreservingFilter(Mat src, Mat& dst, int flags = 1, float sigma_s = 60, float sigma_r = 0.4f)
private static native void edgePreservingFilter_0(long src_nativeObj, long dst_nativeObj, int flags, float sigma_s, float sigma_r);
private static native void edgePreservingFilter_1(long src_nativeObj, long dst_nativeObj);
// C++: void fastNlMeansDenoising(Mat src, Mat& dst, float h = 3, int templateWindowSize = 7, int searchWindowSize = 21)
private static native void fastNlMeansDenoising_0(long src_nativeObj, long dst_nativeObj, float h, int templateWindowSize, int searchWindowSize);
private static native void fastNlMeansDenoising_1(long src_nativeObj, long dst_nativeObj);
// C++: void fastNlMeansDenoising(Mat src, Mat& dst, vector_float h, int templateWindowSize = 7, int searchWindowSize = 21, int normType = NORM_L2)
private static native void fastNlMeansDenoising_2(long src_nativeObj, long dst_nativeObj, long h_mat_nativeObj, int templateWindowSize, int searchWindowSize, int normType);
private static native void fastNlMeansDenoising_3(long src_nativeObj, long dst_nativeObj, long h_mat_nativeObj);
// C++: void fastNlMeansDenoisingColored(Mat src, Mat& dst, float h = 3, float hColor = 3, int templateWindowSize = 7, int searchWindowSize = 21)
private static native void fastNlMeansDenoisingColored_0(long src_nativeObj, long dst_nativeObj, float h, float hColor, int templateWindowSize, int searchWindowSize);
private static native void fastNlMeansDenoisingColored_1(long src_nativeObj, long dst_nativeObj);
// C++: void fastNlMeansDenoisingColoredMulti(vector_Mat srcImgs, Mat& dst, int imgToDenoiseIndex, int temporalWindowSize, float h = 3, float hColor = 3, int templateWindowSize = 7, int searchWindowSize = 21)
private static native void fastNlMeansDenoisingColoredMulti_0(long srcImgs_mat_nativeObj, long dst_nativeObj, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize);
private static native void fastNlMeansDenoisingColoredMulti_1(long srcImgs_mat_nativeObj, long dst_nativeObj, int imgToDenoiseIndex, int temporalWindowSize);
// C++: void fastNlMeansDenoisingMulti(vector_Mat srcImgs, Mat& dst, int imgToDenoiseIndex, int temporalWindowSize, float h = 3, int templateWindowSize = 7, int searchWindowSize = 21)
private static native void fastNlMeansDenoisingMulti_0(long srcImgs_mat_nativeObj, long dst_nativeObj, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize);
private static native void fastNlMeansDenoisingMulti_1(long srcImgs_mat_nativeObj, long dst_nativeObj, int imgToDenoiseIndex, int temporalWindowSize);
// C++: void fastNlMeansDenoisingMulti(vector_Mat srcImgs, Mat& dst, int imgToDenoiseIndex, int temporalWindowSize, vector_float h, int templateWindowSize = 7, int searchWindowSize = 21, int normType = NORM_L2)
private static native void fastNlMeansDenoisingMulti_2(long srcImgs_mat_nativeObj, long dst_nativeObj, int imgToDenoiseIndex, int temporalWindowSize, long h_mat_nativeObj, int templateWindowSize, int searchWindowSize, int normType);
private static native void fastNlMeansDenoisingMulti_3(long srcImgs_mat_nativeObj, long dst_nativeObj, int imgToDenoiseIndex, int temporalWindowSize, long h_mat_nativeObj);
// C++: void illuminationChange(Mat src, Mat mask, Mat& dst, float alpha = 0.2f, float beta = 0.4f)
private static native void illuminationChange_0(long src_nativeObj, long mask_nativeObj, long dst_nativeObj, float alpha, float beta);
private static native void illuminationChange_1(long src_nativeObj, long mask_nativeObj, long dst_nativeObj);
// C++: void inpaint(Mat src, Mat inpaintMask, Mat& dst, double inpaintRadius, int flags)
private static native void inpaint_0(long src_nativeObj, long inpaintMask_nativeObj, long dst_nativeObj, double inpaintRadius, int flags);
// C++: void pencilSketch(Mat src, Mat& dst1, Mat& dst2, float sigma_s = 60, float sigma_r = 0.07f, float shade_factor = 0.02f)
private static native void pencilSketch_0(long src_nativeObj, long dst1_nativeObj, long dst2_nativeObj, float sigma_s, float sigma_r, float shade_factor);
private static native void pencilSketch_1(long src_nativeObj, long dst1_nativeObj, long dst2_nativeObj);
// C++: void seamlessClone(Mat src, Mat dst, Mat mask, Point p, Mat& blend, int flags)
private static native void seamlessClone_0(long src_nativeObj, long dst_nativeObj, long mask_nativeObj, double p_x, double p_y, long blend_nativeObj, int flags);
// C++: void stylization(Mat src, Mat& dst, float sigma_s = 60, float sigma_r = 0.45f)
private static native void stylization_0(long src_nativeObj, long dst_nativeObj, float sigma_s, float sigma_r);
private static native void stylization_1(long src_nativeObj, long dst_nativeObj);
// C++: void textureFlattening(Mat src, Mat mask, Mat& dst, float low_threshold = 30, float high_threshold = 45, int kernel_size = 3)
private static native void textureFlattening_0(long src_nativeObj, long mask_nativeObj, long dst_nativeObj, float low_threshold, float high_threshold, int kernel_size);
private static native void textureFlattening_1(long src_nativeObj, long mask_nativeObj, long dst_nativeObj);
}
| 29,552 | 38.775236 | 236 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/photo/AlignExposures.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.photo;
import java.util.ArrayList;
import java.util.List;
import org.opencv.core.Algorithm;
import org.opencv.core.Mat;
import org.opencv.utils.Converters;
// C++: class AlignExposures
//javadoc: AlignExposures
public class AlignExposures extends Algorithm {
protected AlignExposures(long addr) { super(addr); }
//
// C++: void process(vector_Mat src, vector_Mat dst, Mat times, Mat response)
//
//javadoc: AlignExposures::process(src, dst, times, response)
public void process(List<Mat> src, List<Mat> dst, Mat times, Mat response)
{
Mat src_mat = Converters.vector_Mat_to_Mat(src);
Mat dst_mat = Converters.vector_Mat_to_Mat(dst);
process_0(nativeObj, src_mat.nativeObj, dst_mat.nativeObj, times.nativeObj, response.nativeObj);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: void process(vector_Mat src, vector_Mat dst, Mat times, Mat response)
private static native void process_0(long nativeObj, long src_mat_nativeObj, long dst_mat_nativeObj, long times_nativeObj, long response_nativeObj);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 1,341 | 26.387755 | 152 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/photo/TonemapMantiuk.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.photo;
// C++: class TonemapMantiuk
//javadoc: TonemapMantiuk
public class TonemapMantiuk extends Tonemap {
protected TonemapMantiuk(long addr) { super(addr); }
//
// C++: float getSaturation()
//
//javadoc: TonemapMantiuk::getSaturation()
public float getSaturation()
{
float retVal = getSaturation_0(nativeObj);
return retVal;
}
//
// C++: float getScale()
//
//javadoc: TonemapMantiuk::getScale()
public float getScale()
{
float retVal = getScale_0(nativeObj);
return retVal;
}
//
// C++: void setSaturation(float saturation)
//
//javadoc: TonemapMantiuk::setSaturation(saturation)
public void setSaturation(float saturation)
{
setSaturation_0(nativeObj, saturation);
return;
}
//
// C++: void setScale(float scale)
//
//javadoc: TonemapMantiuk::setScale(scale)
public void setScale(float scale)
{
setScale_0(nativeObj, scale);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: float getSaturation()
private static native float getSaturation_0(long nativeObj);
// C++: float getScale()
private static native float getScale_0(long nativeObj);
// C++: void setSaturation(float saturation)
private static native void setSaturation_0(long nativeObj, float saturation);
// C++: void setScale(float scale)
private static native void setScale_0(long nativeObj, float scale);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 1,838 | 18.357895 | 81 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/photo/MergeDebevec.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.photo;
import java.util.ArrayList;
import java.util.List;
import org.opencv.core.Mat;
import org.opencv.utils.Converters;
// C++: class MergeDebevec
//javadoc: MergeDebevec
public class MergeDebevec extends MergeExposures {
protected MergeDebevec(long addr) { super(addr); }
//
// C++: void process(vector_Mat src, Mat& dst, Mat times, Mat response)
//
//javadoc: MergeDebevec::process(src, dst, times, response)
public void process(List<Mat> src, Mat dst, Mat times, Mat response)
{
Mat src_mat = Converters.vector_Mat_to_Mat(src);
process_0(nativeObj, src_mat.nativeObj, dst.nativeObj, times.nativeObj, response.nativeObj);
return;
}
//
// C++: void process(vector_Mat src, Mat& dst, Mat times)
//
//javadoc: MergeDebevec::process(src, dst, times)
public void process(List<Mat> src, Mat dst, Mat times)
{
Mat src_mat = Converters.vector_Mat_to_Mat(src);
process_1(nativeObj, src_mat.nativeObj, dst.nativeObj, times.nativeObj);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: void process(vector_Mat src, Mat& dst, Mat times, Mat response)
private static native void process_0(long nativeObj, long src_mat_nativeObj, long dst_nativeObj, long times_nativeObj, long response_nativeObj);
// C++: void process(vector_Mat src, Mat& dst, Mat times)
private static native void process_1(long nativeObj, long src_mat_nativeObj, long dst_nativeObj, long times_nativeObj);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 1,776 | 26.765625 | 148 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/photo/Tonemap.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.photo;
import org.opencv.core.Algorithm;
import org.opencv.core.Mat;
// C++: class Tonemap
//javadoc: Tonemap
public class Tonemap extends Algorithm {
protected Tonemap(long addr) { super(addr); }
//
// C++: float getGamma()
//
//javadoc: Tonemap::getGamma()
public float getGamma()
{
float retVal = getGamma_0(nativeObj);
return retVal;
}
//
// C++: void process(Mat src, Mat& dst)
//
//javadoc: Tonemap::process(src, dst)
public void process(Mat src, Mat dst)
{
process_0(nativeObj, src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void setGamma(float gamma)
//
//javadoc: Tonemap::setGamma(gamma)
public void setGamma(float gamma)
{
setGamma_0(nativeObj, gamma);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: float getGamma()
private static native float getGamma_0(long nativeObj);
// C++: void process(Mat src, Mat& dst)
private static native void process_0(long nativeObj, long src_nativeObj, long dst_nativeObj);
// C++: void setGamma(float gamma)
private static native void setGamma_0(long nativeObj, float gamma);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 1,518 | 18.227848 | 97 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/photo/MergeExposures.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.photo;
import java.util.ArrayList;
import java.util.List;
import org.opencv.core.Algorithm;
import org.opencv.core.Mat;
import org.opencv.utils.Converters;
// C++: class MergeExposures
//javadoc: MergeExposures
public class MergeExposures extends Algorithm {
protected MergeExposures(long addr) { super(addr); }
//
// C++: void process(vector_Mat src, Mat& dst, Mat times, Mat response)
//
//javadoc: MergeExposures::process(src, dst, times, response)
public void process(List<Mat> src, Mat dst, Mat times, Mat response)
{
Mat src_mat = Converters.vector_Mat_to_Mat(src);
process_0(nativeObj, src_mat.nativeObj, dst.nativeObj, times.nativeObj, response.nativeObj);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: void process(vector_Mat src, Mat& dst, Mat times, Mat response)
private static native void process_0(long nativeObj, long src_mat_nativeObj, long dst_nativeObj, long times_nativeObj, long response_nativeObj);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 1,258 | 25.229167 | 148 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/photo/CalibrateCRF.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.photo;
import java.util.ArrayList;
import java.util.List;
import org.opencv.core.Algorithm;
import org.opencv.core.Mat;
import org.opencv.utils.Converters;
// C++: class CalibrateCRF
//javadoc: CalibrateCRF
public class CalibrateCRF extends Algorithm {
protected CalibrateCRF(long addr) { super(addr); }
//
// C++: void process(vector_Mat src, Mat& dst, Mat times)
//
//javadoc: CalibrateCRF::process(src, dst, times)
public void process(List<Mat> src, Mat dst, Mat times)
{
Mat src_mat = Converters.vector_Mat_to_Mat(src);
process_0(nativeObj, src_mat.nativeObj, dst.nativeObj, times.nativeObj);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: void process(vector_Mat src, Mat& dst, Mat times)
private static native void process_0(long nativeObj, long src_mat_nativeObj, long dst_nativeObj, long times_nativeObj);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 1,151 | 23 | 123 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/photo/TonemapReinhard.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.photo;
// C++: class TonemapReinhard
//javadoc: TonemapReinhard
public class TonemapReinhard extends Tonemap {
protected TonemapReinhard(long addr) { super(addr); }
//
// C++: float getColorAdaptation()
//
//javadoc: TonemapReinhard::getColorAdaptation()
public float getColorAdaptation()
{
float retVal = getColorAdaptation_0(nativeObj);
return retVal;
}
//
// C++: float getIntensity()
//
//javadoc: TonemapReinhard::getIntensity()
public float getIntensity()
{
float retVal = getIntensity_0(nativeObj);
return retVal;
}
//
// C++: float getLightAdaptation()
//
//javadoc: TonemapReinhard::getLightAdaptation()
public float getLightAdaptation()
{
float retVal = getLightAdaptation_0(nativeObj);
return retVal;
}
//
// C++: void setColorAdaptation(float color_adapt)
//
//javadoc: TonemapReinhard::setColorAdaptation(color_adapt)
public void setColorAdaptation(float color_adapt)
{
setColorAdaptation_0(nativeObj, color_adapt);
return;
}
//
// C++: void setIntensity(float intensity)
//
//javadoc: TonemapReinhard::setIntensity(intensity)
public void setIntensity(float intensity)
{
setIntensity_0(nativeObj, intensity);
return;
}
//
// C++: void setLightAdaptation(float light_adapt)
//
//javadoc: TonemapReinhard::setLightAdaptation(light_adapt)
public void setLightAdaptation(float light_adapt)
{
setLightAdaptation_0(nativeObj, light_adapt);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: float getColorAdaptation()
private static native float getColorAdaptation_0(long nativeObj);
// C++: float getIntensity()
private static native float getIntensity_0(long nativeObj);
// C++: float getLightAdaptation()
private static native float getLightAdaptation_0(long nativeObj);
// C++: void setColorAdaptation(float color_adapt)
private static native void setColorAdaptation_0(long nativeObj, float color_adapt);
// C++: void setIntensity(float intensity)
private static native void setIntensity_0(long nativeObj, float intensity);
// C++: void setLightAdaptation(float light_adapt)
private static native void setLightAdaptation_0(long nativeObj, float light_adapt);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 2,790 | 20.635659 | 87 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/photo/MergeRobertson.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.photo;
import java.util.ArrayList;
import java.util.List;
import org.opencv.core.Mat;
import org.opencv.utils.Converters;
// C++: class MergeRobertson
//javadoc: MergeRobertson
public class MergeRobertson extends MergeExposures {
protected MergeRobertson(long addr) { super(addr); }
//
// C++: void process(vector_Mat src, Mat& dst, Mat times, Mat response)
//
//javadoc: MergeRobertson::process(src, dst, times, response)
public void process(List<Mat> src, Mat dst, Mat times, Mat response)
{
Mat src_mat = Converters.vector_Mat_to_Mat(src);
process_0(nativeObj, src_mat.nativeObj, dst.nativeObj, times.nativeObj, response.nativeObj);
return;
}
//
// C++: void process(vector_Mat src, Mat& dst, Mat times)
//
//javadoc: MergeRobertson::process(src, dst, times)
public void process(List<Mat> src, Mat dst, Mat times)
{
Mat src_mat = Converters.vector_Mat_to_Mat(src);
process_1(nativeObj, src_mat.nativeObj, dst.nativeObj, times.nativeObj);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: void process(vector_Mat src, Mat& dst, Mat times, Mat response)
private static native void process_0(long nativeObj, long src_mat_nativeObj, long dst_nativeObj, long times_nativeObj, long response_nativeObj);
// C++: void process(vector_Mat src, Mat& dst, Mat times)
private static native void process_1(long nativeObj, long src_mat_nativeObj, long dst_nativeObj, long times_nativeObj);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 1,788 | 26.953125 | 148 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/photo/CalibrateRobertson.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.photo;
import org.opencv.core.Mat;
// C++: class CalibrateRobertson
//javadoc: CalibrateRobertson
public class CalibrateRobertson extends CalibrateCRF {
protected CalibrateRobertson(long addr) { super(addr); }
//
// C++: Mat getRadiance()
//
//javadoc: CalibrateRobertson::getRadiance()
public Mat getRadiance()
{
Mat retVal = new Mat(getRadiance_0(nativeObj));
return retVal;
}
//
// C++: float getThreshold()
//
//javadoc: CalibrateRobertson::getThreshold()
public float getThreshold()
{
float retVal = getThreshold_0(nativeObj);
return retVal;
}
//
// C++: int getMaxIter()
//
//javadoc: CalibrateRobertson::getMaxIter()
public int getMaxIter()
{
int retVal = getMaxIter_0(nativeObj);
return retVal;
}
//
// C++: void setMaxIter(int max_iter)
//
//javadoc: CalibrateRobertson::setMaxIter(max_iter)
public void setMaxIter(int max_iter)
{
setMaxIter_0(nativeObj, max_iter);
return;
}
//
// C++: void setThreshold(float threshold)
//
//javadoc: CalibrateRobertson::setThreshold(threshold)
public void setThreshold(float threshold)
{
setThreshold_0(nativeObj, threshold);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: Mat getRadiance()
private static native long getRadiance_0(long nativeObj);
// C++: float getThreshold()
private static native float getThreshold_0(long nativeObj);
// C++: int getMaxIter()
private static native int getMaxIter_0(long nativeObj);
// C++: void setMaxIter(int max_iter)
private static native void setMaxIter_0(long nativeObj, int max_iter);
// C++: void setThreshold(float threshold)
private static native void setThreshold_0(long nativeObj, float threshold);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 2,238 | 18.991071 | 79 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/photo/TonemapDurand.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.photo;
// C++: class TonemapDurand
//javadoc: TonemapDurand
public class TonemapDurand extends Tonemap {
protected TonemapDurand(long addr) { super(addr); }
//
// C++: float getContrast()
//
//javadoc: TonemapDurand::getContrast()
public float getContrast()
{
float retVal = getContrast_0(nativeObj);
return retVal;
}
//
// C++: float getSaturation()
//
//javadoc: TonemapDurand::getSaturation()
public float getSaturation()
{
float retVal = getSaturation_0(nativeObj);
return retVal;
}
//
// C++: float getSigmaColor()
//
//javadoc: TonemapDurand::getSigmaColor()
public float getSigmaColor()
{
float retVal = getSigmaColor_0(nativeObj);
return retVal;
}
//
// C++: float getSigmaSpace()
//
//javadoc: TonemapDurand::getSigmaSpace()
public float getSigmaSpace()
{
float retVal = getSigmaSpace_0(nativeObj);
return retVal;
}
//
// C++: void setContrast(float contrast)
//
//javadoc: TonemapDurand::setContrast(contrast)
public void setContrast(float contrast)
{
setContrast_0(nativeObj, contrast);
return;
}
//
// C++: void setSaturation(float saturation)
//
//javadoc: TonemapDurand::setSaturation(saturation)
public void setSaturation(float saturation)
{
setSaturation_0(nativeObj, saturation);
return;
}
//
// C++: void setSigmaColor(float sigma_color)
//
//javadoc: TonemapDurand::setSigmaColor(sigma_color)
public void setSigmaColor(float sigma_color)
{
setSigmaColor_0(nativeObj, sigma_color);
return;
}
//
// C++: void setSigmaSpace(float sigma_space)
//
//javadoc: TonemapDurand::setSigmaSpace(sigma_space)
public void setSigmaSpace(float sigma_space)
{
setSigmaSpace_0(nativeObj, sigma_space);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: float getContrast()
private static native float getContrast_0(long nativeObj);
// C++: float getSaturation()
private static native float getSaturation_0(long nativeObj);
// C++: float getSigmaColor()
private static native float getSigmaColor_0(long nativeObj);
// C++: float getSigmaSpace()
private static native float getSigmaSpace_0(long nativeObj);
// C++: void setContrast(float contrast)
private static native void setContrast_0(long nativeObj, float contrast);
// C++: void setSaturation(float saturation)
private static native void setSaturation_0(long nativeObj, float saturation);
// C++: void setSigmaColor(float sigma_color)
private static native void setSigmaColor_0(long nativeObj, float sigma_color);
// C++: void setSigmaSpace(float sigma_space)
private static native void setSigmaSpace_0(long nativeObj, float sigma_space);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 3,368 | 19.668712 | 82 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/photo/CalibrateDebevec.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.photo;
// C++: class CalibrateDebevec
//javadoc: CalibrateDebevec
public class CalibrateDebevec extends CalibrateCRF {
protected CalibrateDebevec(long addr) { super(addr); }
//
// C++: bool getRandom()
//
//javadoc: CalibrateDebevec::getRandom()
public boolean getRandom()
{
boolean retVal = getRandom_0(nativeObj);
return retVal;
}
//
// C++: float getLambda()
//
//javadoc: CalibrateDebevec::getLambda()
public float getLambda()
{
float retVal = getLambda_0(nativeObj);
return retVal;
}
//
// C++: int getSamples()
//
//javadoc: CalibrateDebevec::getSamples()
public int getSamples()
{
int retVal = getSamples_0(nativeObj);
return retVal;
}
//
// C++: void setLambda(float lambda)
//
//javadoc: CalibrateDebevec::setLambda(lambda)
public void setLambda(float lambda)
{
setLambda_0(nativeObj, lambda);
return;
}
//
// C++: void setRandom(bool random)
//
//javadoc: CalibrateDebevec::setRandom(random)
public void setRandom(boolean random)
{
setRandom_0(nativeObj, random);
return;
}
//
// C++: void setSamples(int samples)
//
//javadoc: CalibrateDebevec::setSamples(samples)
public void setSamples(int samples)
{
setSamples_0(nativeObj, samples);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: bool getRandom()
private static native boolean getRandom_0(long nativeObj);
// C++: float getLambda()
private static native float getLambda_0(long nativeObj);
// C++: int getSamples()
private static native int getSamples_0(long nativeObj);
// C++: void setLambda(float lambda)
private static native void setLambda_0(long nativeObj, float lambda);
// C++: void setRandom(bool random)
private static native void setRandom_0(long nativeObj, boolean random);
// C++: void setSamples(int samples)
private static native void setSamples_0(long nativeObj, int samples);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 2,481 | 18.24031 | 75 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/photo/MergeMertens.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.photo;
import java.util.ArrayList;
import java.util.List;
import org.opencv.core.Mat;
import org.opencv.utils.Converters;
// C++: class MergeMertens
//javadoc: MergeMertens
public class MergeMertens extends MergeExposures {
protected MergeMertens(long addr) { super(addr); }
//
// C++: float getContrastWeight()
//
//javadoc: MergeMertens::getContrastWeight()
public float getContrastWeight()
{
float retVal = getContrastWeight_0(nativeObj);
return retVal;
}
//
// C++: float getExposureWeight()
//
//javadoc: MergeMertens::getExposureWeight()
public float getExposureWeight()
{
float retVal = getExposureWeight_0(nativeObj);
return retVal;
}
//
// C++: float getSaturationWeight()
//
//javadoc: MergeMertens::getSaturationWeight()
public float getSaturationWeight()
{
float retVal = getSaturationWeight_0(nativeObj);
return retVal;
}
//
// C++: void process(vector_Mat src, Mat& dst, Mat times, Mat response)
//
//javadoc: MergeMertens::process(src, dst, times, response)
public void process(List<Mat> src, Mat dst, Mat times, Mat response)
{
Mat src_mat = Converters.vector_Mat_to_Mat(src);
process_0(nativeObj, src_mat.nativeObj, dst.nativeObj, times.nativeObj, response.nativeObj);
return;
}
//
// C++: void process(vector_Mat src, Mat& dst)
//
//javadoc: MergeMertens::process(src, dst)
public void process(List<Mat> src, Mat dst)
{
Mat src_mat = Converters.vector_Mat_to_Mat(src);
process_1(nativeObj, src_mat.nativeObj, dst.nativeObj);
return;
}
//
// C++: void setContrastWeight(float contrast_weiht)
//
//javadoc: MergeMertens::setContrastWeight(contrast_weiht)
public void setContrastWeight(float contrast_weiht)
{
setContrastWeight_0(nativeObj, contrast_weiht);
return;
}
//
// C++: void setExposureWeight(float exposure_weight)
//
//javadoc: MergeMertens::setExposureWeight(exposure_weight)
public void setExposureWeight(float exposure_weight)
{
setExposureWeight_0(nativeObj, exposure_weight);
return;
}
//
// C++: void setSaturationWeight(float saturation_weight)
//
//javadoc: MergeMertens::setSaturationWeight(saturation_weight)
public void setSaturationWeight(float saturation_weight)
{
setSaturationWeight_0(nativeObj, saturation_weight);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: float getContrastWeight()
private static native float getContrastWeight_0(long nativeObj);
// C++: float getExposureWeight()
private static native float getExposureWeight_0(long nativeObj);
// C++: float getSaturationWeight()
private static native float getSaturationWeight_0(long nativeObj);
// C++: void process(vector_Mat src, Mat& dst, Mat times, Mat response)
private static native void process_0(long nativeObj, long src_mat_nativeObj, long dst_nativeObj, long times_nativeObj, long response_nativeObj);
// C++: void process(vector_Mat src, Mat& dst)
private static native void process_1(long nativeObj, long src_mat_nativeObj, long dst_nativeObj);
// C++: void setContrastWeight(float contrast_weiht)
private static native void setContrastWeight_0(long nativeObj, float contrast_weiht);
// C++: void setExposureWeight(float exposure_weight)
private static native void setExposureWeight_0(long nativeObj, float exposure_weight);
// C++: void setSaturationWeight(float saturation_weight)
private static native void setSaturationWeight_0(long nativeObj, float saturation_weight);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 4,163 | 24.084337 | 148 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/photo/TonemapDrago.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.photo;
// C++: class TonemapDrago
//javadoc: TonemapDrago
public class TonemapDrago extends Tonemap {
protected TonemapDrago(long addr) { super(addr); }
//
// C++: float getBias()
//
//javadoc: TonemapDrago::getBias()
public float getBias()
{
float retVal = getBias_0(nativeObj);
return retVal;
}
//
// C++: float getSaturation()
//
//javadoc: TonemapDrago::getSaturation()
public float getSaturation()
{
float retVal = getSaturation_0(nativeObj);
return retVal;
}
//
// C++: void setBias(float bias)
//
//javadoc: TonemapDrago::setBias(bias)
public void setBias(float bias)
{
setBias_0(nativeObj, bias);
return;
}
//
// C++: void setSaturation(float saturation)
//
//javadoc: TonemapDrago::setSaturation(saturation)
public void setSaturation(float saturation)
{
setSaturation_0(nativeObj, saturation);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: float getBias()
private static native float getBias_0(long nativeObj);
// C++: float getSaturation()
private static native float getSaturation_0(long nativeObj);
// C++: void setBias(float bias)
private static native void setBias_0(long nativeObj, float bias);
// C++: void setSaturation(float saturation)
private static native void setSaturation_0(long nativeObj, float saturation);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 1,804 | 18 | 81 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/ml/Boost.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.ml;
// C++: class Boost
//javadoc: Boost
public class Boost extends DTrees {
protected Boost(long addr) { super(addr); }
public static final int
DISCRETE = 0,
REAL = 1,
LOGIT = 2,
GENTLE = 3;
//
// C++: static Ptr_Boost create()
//
//javadoc: Boost::create()
public static Boost create()
{
Boost retVal = new Boost(create_0());
return retVal;
}
//
// C++: double getWeightTrimRate()
//
//javadoc: Boost::getWeightTrimRate()
public double getWeightTrimRate()
{
double retVal = getWeightTrimRate_0(nativeObj);
return retVal;
}
//
// C++: int getBoostType()
//
//javadoc: Boost::getBoostType()
public int getBoostType()
{
int retVal = getBoostType_0(nativeObj);
return retVal;
}
//
// C++: int getWeakCount()
//
//javadoc: Boost::getWeakCount()
public int getWeakCount()
{
int retVal = getWeakCount_0(nativeObj);
return retVal;
}
//
// C++: void setBoostType(int val)
//
//javadoc: Boost::setBoostType(val)
public void setBoostType(int val)
{
setBoostType_0(nativeObj, val);
return;
}
//
// C++: void setWeakCount(int val)
//
//javadoc: Boost::setWeakCount(val)
public void setWeakCount(int val)
{
setWeakCount_0(nativeObj, val);
return;
}
//
// C++: void setWeightTrimRate(double val)
//
//javadoc: Boost::setWeightTrimRate(val)
public void setWeightTrimRate(double val)
{
setWeightTrimRate_0(nativeObj, val);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: static Ptr_Boost create()
private static native long create_0();
// C++: double getWeightTrimRate()
private static native double getWeightTrimRate_0(long nativeObj);
// C++: int getBoostType()
private static native int getBoostType_0(long nativeObj);
// C++: int getWeakCount()
private static native int getWeakCount_0(long nativeObj);
// C++: void setBoostType(int val)
private static native void setBoostType_0(long nativeObj, int val);
// C++: void setWeakCount(int val)
private static native void setWeakCount_0(long nativeObj, int val);
// C++: void setWeightTrimRate(double val)
private static native void setWeightTrimRate_0(long nativeObj, double val);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 2,868 | 17.751634 | 79 | java |
self | self-master/lib/opencv/android/sdk/java/src/org/opencv/ml/RTrees.java |
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.ml;
import org.opencv.core.Mat;
import org.opencv.core.TermCriteria;
// C++: class RTrees
//javadoc: RTrees
public class RTrees extends DTrees {
protected RTrees(long addr) { super(addr); }
//
// C++: Mat getVarImportance()
//
//javadoc: RTrees::getVarImportance()
public Mat getVarImportance()
{
Mat retVal = new Mat(getVarImportance_0(nativeObj));
return retVal;
}
//
// C++: static Ptr_RTrees create()
//
//javadoc: RTrees::create()
public static RTrees create()
{
RTrees retVal = new RTrees(create_0());
return retVal;
}
//
// C++: TermCriteria getTermCriteria()
//
//javadoc: RTrees::getTermCriteria()
public TermCriteria getTermCriteria()
{
TermCriteria retVal = new TermCriteria(getTermCriteria_0(nativeObj));
return retVal;
}
//
// C++: bool getCalculateVarImportance()
//
//javadoc: RTrees::getCalculateVarImportance()
public boolean getCalculateVarImportance()
{
boolean retVal = getCalculateVarImportance_0(nativeObj);
return retVal;
}
//
// C++: int getActiveVarCount()
//
//javadoc: RTrees::getActiveVarCount()
public int getActiveVarCount()
{
int retVal = getActiveVarCount_0(nativeObj);
return retVal;
}
//
// C++: void setActiveVarCount(int val)
//
//javadoc: RTrees::setActiveVarCount(val)
public void setActiveVarCount(int val)
{
setActiveVarCount_0(nativeObj, val);
return;
}
//
// C++: void setCalculateVarImportance(bool val)
//
//javadoc: RTrees::setCalculateVarImportance(val)
public void setCalculateVarImportance(boolean val)
{
setCalculateVarImportance_0(nativeObj, val);
return;
}
//
// C++: void setTermCriteria(TermCriteria val)
//
//javadoc: RTrees::setTermCriteria(val)
public void setTermCriteria(TermCriteria val)
{
setTermCriteria_0(nativeObj, val.type, val.maxCount, val.epsilon);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: Mat getVarImportance()
private static native long getVarImportance_0(long nativeObj);
// C++: static Ptr_RTrees create()
private static native long create_0();
// C++: TermCriteria getTermCriteria()
private static native double[] getTermCriteria_0(long nativeObj);
// C++: bool getCalculateVarImportance()
private static native boolean getCalculateVarImportance_0(long nativeObj);
// C++: int getActiveVarCount()
private static native int getActiveVarCount_0(long nativeObj);
// C++: void setActiveVarCount(int val)
private static native void setActiveVarCount_0(long nativeObj, int val);
// C++: void setCalculateVarImportance(bool val)
private static native void setCalculateVarImportance_0(long nativeObj, boolean val);
// C++: void setTermCriteria(TermCriteria val)
private static native void setTermCriteria_0(long nativeObj, int val_type, int val_maxCount, double val_epsilon);
// native support for java finalize()
private static native void delete(long nativeObj);
}
| 3,521 | 20.47561 | 117 | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.