Revision 43936
| trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.exportto/org.gvsig.exportto.lib/org.gvsig.exportto.lib.api/src/main/java/org/gvsig/export/ExportParametersGeometry.java | ||
|---|---|---|
| 55 | 55 |
|
| 56 | 56 |
public void setTryToFixGeometry(boolean tryToFixGeometry); |
| 57 | 57 |
|
| 58 |
public String getGeometryFieldName(); |
|
| 58 |
public String getSourceGeometryFieldName();
|
|
| 59 | 59 |
|
| 60 |
public void setGeometryFieldName(String geometryFieldName); |
|
| 60 |
public void setSourceGeometryFieldName(String geometryFieldName);
|
|
| 61 | 61 |
|
| 62 |
public GeometryType getGeometryType(); |
|
| 62 |
public GeometryType getTargetGeometryType();
|
|
| 63 | 63 |
|
| 64 |
public int getGeometryTypeAsInt(); |
|
| 64 |
public int getTargetGeometryTypeAsInt();
|
|
| 65 | 65 |
|
| 66 |
public int getGeometrySubtype(); |
|
| 66 |
public int getTargetGeometrySubtype();
|
|
| 67 | 67 |
|
| 68 |
public void setGeometryType(GeometryType type); |
|
| 68 |
public void setTargetGeometryType(GeometryType type);
|
|
| 69 | 69 |
|
| 70 |
public void setGeometryType(int type); |
|
| 70 |
public void setTargetGeometryType(int type);
|
|
| 71 | 71 |
|
| 72 |
public void setGeometrySubtype(int subtype); |
|
| 72 |
public void setTargetGeometrySubtype(int subtype);
|
|
| 73 | 73 |
} |
| trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.exportto/org.gvsig.exportto.lib/org.gvsig.exportto.lib.api/src/main/java/org/gvsig/export/spi/AbstractExportParametersGeometry.java | ||
|---|---|---|
| 121 | 121 |
} |
| 122 | 122 |
|
| 123 | 123 |
@Override |
| 124 |
public String getGeometryFieldName() {
|
|
| 124 |
public String getSourceGeometryFieldName() {
|
|
| 125 | 125 |
return this.geometryFieldName; |
| 126 | 126 |
} |
| 127 | 127 |
|
| 128 | 128 |
@Override |
| 129 |
public void setGeometryFieldName(String geometryFieldName) {
|
|
| 129 |
public void setSourceGeometryFieldName(String geometryFieldName) {
|
|
| 130 | 130 |
this.geometryFieldName = geometryFieldName; |
| 131 | 131 |
} |
| 132 | 132 |
|
| 133 | 133 |
@Override |
| 134 |
public int getGeometryTypeAsInt() {
|
|
| 134 |
public int getTargetGeometryTypeAsInt() {
|
|
| 135 | 135 |
return geometryType; |
| 136 | 136 |
} |
| 137 | 137 |
|
| 138 | 138 |
@Override |
| 139 |
public int getGeometrySubtype() {
|
|
| 139 |
public int getTargetGeometrySubtype() {
|
|
| 140 | 140 |
return geometrySubtype; |
| 141 | 141 |
} |
| 142 | 142 |
|
| 143 | 143 |
@Override |
| 144 |
public void setGeometryType(int geometryType) {
|
|
| 144 |
public void setTargetGeometryType(int geometryType) {
|
|
| 145 | 145 |
this.geometryType = geometryType; |
| 146 | 146 |
} |
| 147 | 147 |
|
| 148 | 148 |
@Override |
| 149 |
public void setGeometrySubtype(int subtype) {
|
|
| 149 |
public void setTargetGeometrySubtype(int subtype) {
|
|
| 150 | 150 |
this.geometrySubtype = subtype; |
| 151 | 151 |
} |
| 152 | 152 |
|
| 153 | 153 |
@Override |
| 154 |
public void setGeometryType(GeometryType type) {
|
|
| 154 |
public void setTargetGeometryType(GeometryType type) {
|
|
| 155 | 155 |
this.geometryType = type.getType(); |
| 156 | 156 |
this.geometrySubtype = type.getSubType(); |
| 157 | 157 |
} |
| 158 | 158 |
|
| 159 | 159 |
@Override |
| 160 |
public GeometryType getGeometryType() {
|
|
| 160 |
public GeometryType getTargetGeometryType() {
|
|
| 161 | 161 |
try {
|
| 162 | 162 |
GeometryManager geomManager = GeometryLocator.getGeometryManager(); |
| 163 | 163 |
GeometryType type = geomManager.getGeometryType( |
| trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.exportto/org.gvsig.exportto.lib/org.gvsig.exportto.lib.api/src/main/java/org/gvsig/export/spi/AbstractExportService.java | ||
|---|---|---|
| 5 | 5 |
import java.util.HashSet; |
| 6 | 6 |
import java.util.List; |
| 7 | 7 |
import java.util.Set; |
| 8 |
import org.cresques.cts.ICoordTrans; |
|
| 9 |
import org.cresques.cts.IProjection; |
|
| 10 | 8 |
import org.gvsig.export.ExportException; |
| 11 | 9 |
import org.gvsig.export.ExportLocator; |
| 12 | 10 |
import org.gvsig.export.ExportParameters; |
| 11 |
import org.gvsig.export.ExportParametersGeometry; |
|
| 12 |
import org.gvsig.export.spi.ExportServiceManager.FixGeometryStatus; |
|
| 13 | 13 |
import org.gvsig.fmap.dal.DALLocator; |
| 14 | 14 |
import org.gvsig.fmap.dal.DataManager; |
| 15 | 15 |
import org.gvsig.fmap.dal.DataServerExplorer; |
| ... | ... | |
| 21 | 21 |
import org.gvsig.fmap.dal.feature.FeatureSet; |
| 22 | 22 |
import org.gvsig.fmap.dal.feature.FeatureStore; |
| 23 | 23 |
import org.gvsig.fmap.dal.feature.FeatureType; |
| 24 |
import org.gvsig.fmap.geom.Geometry; |
|
| 25 | 24 |
import org.gvsig.tools.ToolsLocator; |
| 26 | 25 |
import org.gvsig.tools.dispose.DisposableIterator; |
| 27 | 26 |
import org.gvsig.tools.dispose.DisposeUtils; |
| ... | ... | |
| 124 | 123 |
|
| 125 | 124 |
abstract protected OpenDataStoreParameters createTargetOpenStoreParameters() throws ExportException; |
| 126 | 125 |
|
| 126 |
|
|
| 127 |
protected static class InvalidGeometryException extends ExportException {
|
|
| 128 |
|
|
| 129 |
public InvalidGeometryException(Feature feature, String checkMessage) {
|
|
| 130 |
super(checkMessage, feature); |
|
| 131 |
} |
|
| 132 |
} |
|
| 133 |
|
|
| 127 | 134 |
@Override |
| 128 | 135 |
public void export(FeatureSet featureSet) throws ExportException {
|
| 129 | 136 |
DataServerExplorer explorer = createServerExplorer(); |
| ... | ... | |
| 135 | 142 |
|
| 136 | 143 |
DisposableIterator it = null; |
| 137 | 144 |
FeatureStore target = null; |
| 138 |
EditableFeature newfeature = null;
|
|
| 145 |
EditableFeature targetFeature = null;
|
|
| 139 | 146 |
try {
|
| 140 | 147 |
this.getTaskStatus().setRangeOfValues(0, featureSet.getSize()); |
| 141 | 148 |
|
| ... | ... | |
| 144 | 151 |
dataManager.newStore(explorerName, providerName, newStoreParameters, true); |
| 145 | 152 |
target = (FeatureStore) dataManager.openStore(providerName, openStoreParameters); |
| 146 | 153 |
|
| 147 |
FeatureType targetType = target.getDefaultFeatureType(); |
|
| 154 |
FeatureType theTargetFeatureType = target.getDefaultFeatureType(); |
|
| 155 |
FeatureType theSourceFeatureType = featureSet.getDefaultFeatureType(); |
|
| 148 | 156 |
|
| 157 |
ExportGeometryHelper geomHelper = null; |
|
| 158 |
if( this.getParameters() instanceof ExportParametersGeometry ) {
|
|
| 159 |
geomHelper = ExportLocator.getServiceManager().createGeometryHelper( |
|
| 160 |
(ExportParametersGeometry) this.getParameters(), |
|
| 161 |
theTargetFeatureType, |
|
| 162 |
theSourceFeatureType |
|
| 163 |
); |
|
| 164 |
if( !geomHelper.canProcessGeometry() ) {
|
|
| 165 |
geomHelper = null; |
|
| 166 |
} |
|
| 167 |
} |
|
| 168 |
// ============================================ |
|
| 169 |
|
|
| 149 | 170 |
target.edit(FeatureStore.MODE_APPEND); |
| 150 | 171 |
it = featureSet.fastIterator(); |
| 151 | 172 |
|
| 152 |
IProjection targetProjection; |
|
| 153 |
FeatureAttributeDescriptor defaultGeom = target.getDefaultFeatureType().getDefaultGeometryAttribute(); |
|
| 154 |
if (defaultGeom!=null) {
|
|
| 155 |
targetProjection = defaultGeom.getSRS(); |
|
| 156 |
} else {
|
|
| 157 |
targetProjection = null; |
|
| 158 |
} |
|
| 159 |
|
|
| 160 | 173 |
long featureCount = 0; |
| 161 | 174 |
while (it.hasNext()) {
|
| 162 |
Feature feature = (Feature) it.next(); |
|
| 163 |
newfeature = target.createNewFeature(targetType, true); |
|
| 164 |
copyValues(feature, newfeature); |
|
| 165 |
// ================================================ |
|
| 166 |
// Reprojection stuff |
|
| 167 |
Geometry reproj_geom; |
|
| 168 |
IProjection sourceProjection = feature.getDefaultSRS(); |
|
| 175 |
this.getTaskStatus().setCurValue(featureCount); |
|
| 169 | 176 |
|
| 170 |
ICoordTrans coord_trans;
|
|
| 171 |
// this comparison is perhaps too preventive
|
|
| 172 |
// we could have two instances of same projection
|
|
| 173 |
// so we would do more computations than needed |
|
| 174 |
if (sourceProjection != null
|
|
| 175 |
&& targetProjection != null
|
|
| 176 |
&& sourceProjection != targetProjection) {
|
|
| 177 |
|
|
| 178 |
coord_trans = sourceProjection.getCT(targetProjection);
|
|
| 179 |
reproj_geom = feature.getDefaultGeometry();
|
|
| 180 |
reproj_geom = reproj_geom.cloneGeometry();
|
|
| 181 |
reproj_geom.reProject(coord_trans);
|
|
| 182 |
newfeature.setDefaultGeometry(reproj_geom);
|
|
| 177 |
Feature sourceFeature = (Feature) it.next();
|
|
| 178 |
targetFeature = target.createNewFeature(theTargetFeatureType, true);
|
|
| 179 |
copyValues(sourceFeature, targetFeature);
|
|
| 180 |
|
|
| 181 |
if( geomHelper!=null ) {
|
|
| 182 |
switch(geomHelper.copyGeometry(sourceFeature,targetFeature)) {
|
|
| 183 |
case FixGeometryStatus.STATE_OK:
|
|
| 184 |
break; |
|
| 185 |
case FixGeometryStatus.STATE_SKIP:
|
|
| 186 |
continue;
|
|
| 187 |
case FixGeometryStatus.STATE_ABORT:
|
|
| 188 |
throw new InvalidGeometryException(targetFeature, geomHelper.getLastErrorMessage());
|
|
| 189 |
}
|
|
| 183 | 190 |
} |
| 184 |
// ================================================ |
|
| 191 |
|
|
| 192 |
target.insert(targetFeature); |
|
| 185 | 193 |
|
| 186 |
target.insert(newfeature); |
|
| 187 |
|
|
| 188 | 194 |
featureCount++; |
| 189 |
this.getTaskStatus().setCurValue(featureCount); |
|
| 190 | 195 |
|
| 191 | 196 |
if (this.getTaskStatus().isCancellationRequested()) {
|
| 192 | 197 |
return; |
| ... | ... | |
| 198 | 203 |
fireFinishedListener(); |
| 199 | 204 |
} catch (Exception e) {
|
| 200 | 205 |
fireCancelledListeners(); |
| 201 |
throw new ExportException(e, newfeature);
|
|
| 206 |
throw new ExportException(e, targetFeature);
|
|
| 202 | 207 |
} finally {
|
| 203 | 208 |
DisposeUtils.dispose(it); |
| 204 | 209 |
DisposeUtils.dispose(featureSet); |
| 205 | 210 |
DisposeUtils.dispose(target); |
| 206 |
} |
|
| 207 | 211 |
} |
| 212 |
} |
|
| 208 | 213 |
|
| 209 | 214 |
protected void copyValues(Feature source, EditableFeature target) {
|
| 210 | 215 |
FeatureType sourceType= source.getType(); |
| 211 | 216 |
FeatureType targetType = target.getType(); |
| 212 |
for( FeatureAttributeDescriptor targetAttr : targetType) {
|
|
| 217 |
for( FeatureAttributeDescriptor targetAttr: targetType) {
|
|
| 213 | 218 |
String targetAttrName = targetAttr.getName(); |
| 214 | 219 |
String sourceAttrName = getAttributeNamesTranslator().getSourceName(targetAttrName); |
| 215 | 220 |
FeatureAttributeDescriptor sourceAttr = sourceType.getAttributeDescriptor(sourceAttrName); |
| trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.exportto/org.gvsig.exportto.lib/org.gvsig.exportto.lib.api/src/main/java/org/gvsig/export/spi/ExportGeometryHelper.java | ||
|---|---|---|
| 1 |
package org.gvsig.export.spi; |
|
| 2 |
|
|
| 3 |
import org.gvsig.fmap.dal.feature.EditableFeature; |
|
| 4 |
import org.gvsig.fmap.dal.feature.Feature; |
|
| 5 |
|
|
| 6 |
/** |
|
| 7 |
* |
|
| 8 |
* @author jjdelcerro |
|
| 9 |
*/ |
|
| 10 |
public interface ExportGeometryHelper {
|
|
| 11 |
|
|
| 12 |
boolean canProcessGeometry(); |
|
| 13 |
|
|
| 14 |
int copyGeometry(Feature sourceFeature, EditableFeature targetFeature); |
|
| 15 |
|
|
| 16 |
String getLastErrorMessage(); |
|
| 17 |
|
|
| 18 |
} |
|
| trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.exportto/org.gvsig.exportto.lib/org.gvsig.exportto.lib.api/src/main/java/org/gvsig/export/spi/ExportServiceManager.java | ||
|---|---|---|
| 48 | 48 |
ICoordTrans coord_trans, |
| 49 | 49 |
Geometry geometry |
| 50 | 50 |
); |
| 51 |
|
|
| 52 |
public ExportGeometryHelper createGeometryHelper( |
|
| 53 |
ExportParametersGeometry parameters, |
|
| 54 |
FeatureType theTargetFeatureType, |
|
| 55 |
FeatureType theSourceFeatureType |
|
| 56 |
); |
|
| 51 | 57 |
} |
| trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.exportto/org.gvsig.exportto.lib/org.gvsig.exportto.lib.impl/src/main/java/org/gvsig/export/impl/service/DefaultExportGeometryHelper.java | ||
|---|---|---|
| 1 |
package org.gvsig.export.impl.service; |
|
| 2 |
|
|
| 3 |
import org.apache.commons.lang3.StringUtils; |
|
| 4 |
import org.cresques.cts.ICoordTrans; |
|
| 5 |
import org.cresques.cts.IProjection; |
|
| 6 |
import org.gvsig.export.ExportLocator; |
|
| 7 |
import org.gvsig.export.ExportParametersGeometry; |
|
| 8 |
import org.gvsig.export.spi.ExportGeometryHelper; |
|
| 9 |
import org.gvsig.export.spi.ExportServiceManager; |
|
| 10 |
import org.gvsig.fmap.dal.DataTypes; |
|
| 11 |
import org.gvsig.fmap.dal.feature.EditableFeature; |
|
| 12 |
import org.gvsig.fmap.dal.feature.Feature; |
|
| 13 |
import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor; |
|
| 14 |
import org.gvsig.fmap.dal.feature.FeatureType; |
|
| 15 |
import org.gvsig.fmap.geom.Geometry; |
|
| 16 |
|
|
| 17 |
/** |
|
| 18 |
* |
|
| 19 |
* @author jjdelcerro |
|
| 20 |
*/ |
|
| 21 |
public class DefaultExportGeometryHelper implements ExportGeometryHelper {
|
|
| 22 |
private final int targetGeometryIndex; |
|
| 23 |
private final int sourceGeometryIndex; |
|
| 24 |
private final ICoordTrans coord_trans; |
|
| 25 |
|
|
| 26 |
private final ExportServiceManager serviceManager; |
|
| 27 |
private final ExportParametersGeometry parameters; |
|
| 28 |
private String lastErrorMessage; |
|
| 29 |
|
|
| 30 |
public DefaultExportGeometryHelper( |
|
| 31 |
ExportParametersGeometry parameters, |
|
| 32 |
FeatureType theTargetFeatureType, |
|
| 33 |
FeatureType theSourceFeatureType |
|
| 34 |
) {
|
|
| 35 |
this.serviceManager = ExportLocator.getServiceManager(); |
|
| 36 |
this.parameters = parameters; |
|
| 37 |
|
|
| 38 |
FeatureAttributeDescriptor sourceGeomAtt = theSourceFeatureType.getDefaultGeometryAttribute(); |
|
| 39 |
FeatureAttributeDescriptor targetGeomAtt; |
|
| 40 |
|
|
| 41 |
String sourceGeometryFieldName = this.parameters.getSourceGeometryFieldName(); |
|
| 42 |
if( !StringUtils.isEmpty(sourceGeometryFieldName) ) {
|
|
| 43 |
sourceGeomAtt = theSourceFeatureType.getAttributeDescriptor(sourceGeometryFieldName); |
|
| 44 |
} |
|
| 45 |
if (sourceGeomAtt == null) {
|
|
| 46 |
// Si el origen no tiene geometria, no haremos nada con las |
|
| 47 |
// geometrias. |
|
| 48 |
this.targetGeometryIndex = -1; |
|
| 49 |
this.sourceGeometryIndex = -1; |
|
| 50 |
this.coord_trans = null; |
|
| 51 |
return; |
|
| 52 |
} |
|
| 53 |
switch( this.getGeometryColumnCount(theTargetFeatureType) ) {
|
|
| 54 |
case 0: |
|
| 55 |
// Si el destino no tiene campo geometry no haremos nada con |
|
| 56 |
// las geometrias. |
|
| 57 |
this.targetGeometryIndex = -1; |
|
| 58 |
this.sourceGeometryIndex = -1; |
|
| 59 |
this.coord_trans = null; |
|
| 60 |
return; |
|
| 61 |
case 1: |
|
| 62 |
// Si solo hay una columna de geometria asignaremos las geometrias |
|
| 63 |
// independientemente de como se llamen los campos. |
|
| 64 |
targetGeomAtt = theTargetFeatureType.getDefaultGeometryAttribute(); |
|
| 65 |
break; |
|
| 66 |
default: |
|
| 67 |
// Si hay mas de una geometria en el target y hay un campo de tipo |
|
| 68 |
// geometria que coincida en nombre con el del source, usamos ese. |
|
| 69 |
targetGeomAtt = theTargetFeatureType.getAttributeDescriptor(sourceGeomAtt.getName()); |
|
| 70 |
if( targetGeomAtt == null || targetGeomAtt.getType()!=DataTypes.GEOMETRY ) {
|
|
| 71 |
// Si no coinciden por nombre y tipo, pillaremos el primer campo |
|
| 72 |
// geometry por defecto del target. |
|
| 73 |
targetGeomAtt = theTargetFeatureType.getDefaultGeometryAttribute(); |
|
| 74 |
if( targetGeomAtt==null ) {
|
|
| 75 |
targetGeomAtt = this.getFirstGeometryColumn(theTargetFeatureType); |
|
| 76 |
if( targetGeomAtt == null ) {
|
|
| 77 |
this.targetGeometryIndex = -1; |
|
| 78 |
this.sourceGeometryIndex = -1; |
|
| 79 |
this.coord_trans = null; |
|
| 80 |
return; |
|
| 81 |
} |
|
| 82 |
} |
|
| 83 |
} |
|
| 84 |
} |
|
| 85 |
|
|
| 86 |
IProjection sourceProjection = this.parameters.getTargetProjection(); |
|
| 87 |
IProjection targetProjection = sourceGeomAtt.getSRS(); |
|
| 88 |
if( targetProjection == null ) {
|
|
| 89 |
targetProjection = sourceProjection; |
|
| 90 |
} |
|
| 91 |
// this comparison is perhaps too preventive |
|
| 92 |
// we could have two instances of same projection |
|
| 93 |
// so we would do more computations than needed |
|
| 94 |
if (sourceProjection != null && targetProjection != null && sourceProjection != targetProjection) {
|
|
| 95 |
this.coord_trans = sourceProjection.getCT(targetProjection); |
|
| 96 |
} else {
|
|
| 97 |
this.coord_trans = null; |
|
| 98 |
} |
|
| 99 |
this.sourceGeometryIndex = sourceGeomAtt.getIndex(); |
|
| 100 |
this.targetGeometryIndex = targetGeomAtt.getIndex(); |
|
| 101 |
} |
|
| 102 |
|
|
| 103 |
private int getGeometryColumnCount(FeatureType featureType) {
|
|
| 104 |
int count = 0; |
|
| 105 |
for( int i=0; i<featureType.size(); i++ ) {
|
|
| 106 |
if( featureType.getAttributeDescriptor(i).getType()==DataTypes.GEOMETRY ) {
|
|
| 107 |
count++; |
|
| 108 |
} |
|
| 109 |
} |
|
| 110 |
return count; |
|
| 111 |
} |
|
| 112 |
|
|
| 113 |
@Override |
|
| 114 |
public String getLastErrorMessage() {
|
|
| 115 |
return this.lastErrorMessage; |
|
| 116 |
} |
|
| 117 |
|
|
| 118 |
@Override |
|
| 119 |
public int copyGeometry( |
|
| 120 |
Feature sourceFeature, |
|
| 121 |
EditableFeature targetFeature |
|
| 122 |
) {
|
|
| 123 |
if( this.sourceGeometryIndex<0 || this.targetGeometryIndex<0 ) {
|
|
| 124 |
return ExportServiceManager.FixGeometryStatus.STATE_OK; |
|
| 125 |
} |
|
| 126 |
Geometry geometry = sourceFeature.getGeometry(this.sourceGeometryIndex); |
|
| 127 |
ExportServiceManager.FixGeometryStatus check = serviceManager.fixGeometry( |
|
| 128 |
this.parameters, |
|
| 129 |
this.coord_trans, |
|
| 130 |
geometry |
|
| 131 |
); |
|
| 132 |
if( check.getState() == ExportServiceManager.FixGeometryStatus.STATE_OK ) {
|
|
| 133 |
targetFeature.setGeometry(this.targetGeometryIndex, check.getGeometry()); |
|
| 134 |
} |
|
| 135 |
this.lastErrorMessage = check.getMessage(); |
|
| 136 |
return check.getState(); |
|
| 137 |
} |
|
| 138 |
|
|
| 139 |
@Override |
|
| 140 |
public boolean canProcessGeometry() {
|
|
| 141 |
return this.sourceGeometryIndex>=0 && this.targetGeometryIndex>=0 ; |
|
| 142 |
} |
|
| 143 |
|
|
| 144 |
private FeatureAttributeDescriptor getFirstGeometryColumn(FeatureType featureType) {
|
|
| 145 |
for( int i=0; i<featureType.size(); i++ ) {
|
|
| 146 |
FeatureAttributeDescriptor descriptor = featureType.getAttributeDescriptor(i); |
|
| 147 |
if( descriptor.getType()==DataTypes.GEOMETRY ) {
|
|
| 148 |
return descriptor; |
|
| 149 |
} |
|
| 150 |
} |
|
| 151 |
return null; |
|
| 152 |
} |
|
| 153 |
|
|
| 154 |
|
|
| 155 |
} |
|
| trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.exportto/org.gvsig.exportto.lib/org.gvsig.exportto.lib.impl/src/main/java/org/gvsig/export/impl/service/DefaultExportServiceManager.java | ||
|---|---|---|
| 16 | 16 |
import org.gvsig.export.Filter; |
| 17 | 17 |
import org.gvsig.export.impl.ExportGeometryUtils; |
| 18 | 18 |
import org.gvsig.export.spi.AttributeNamesTranslator; |
| 19 |
import org.gvsig.export.spi.ExportGeometryHelper; |
|
| 19 | 20 |
import org.gvsig.export.spi.ExportService; |
| 20 | 21 |
import org.gvsig.export.spi.ExportServiceFactory; |
| 21 | 22 |
import org.gvsig.export.spi.ExportServiceManager; |
| ... | ... | |
| 123 | 124 |
) {
|
| 124 | 125 |
return ExportGeometryUtils.fixGeometry(parmeters, coord_trans, geometry); |
| 125 | 126 |
} |
| 127 |
|
|
| 128 |
@Override |
|
| 129 |
public ExportGeometryHelper createGeometryHelper(ExportParametersGeometry parameters, FeatureType theTargetFeatureType, FeatureType theSourceFeatureType) {
|
|
| 130 |
DefaultExportGeometryHelper helper = new DefaultExportGeometryHelper( |
|
| 131 |
parameters, |
|
| 132 |
theTargetFeatureType, |
|
| 133 |
theSourceFeatureType |
|
| 134 |
); |
|
| 135 |
return helper; |
|
| 136 |
|
|
| 137 |
} |
|
| 126 | 138 |
} |
| trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.exportto/org.gvsig.exportto.swing/org.gvsig.exportto.swing.impl/src/main/java/org/gvsig/export/swing/impl/panels/SelectGeometryTypePanel.java | ||
|---|---|---|
| 70 | 70 |
FeatureAttributeDescriptor geomDescriptor = ft.getDefaultGeometryAttribute(); |
| 71 | 71 |
|
| 72 | 72 |
if( geomDescriptor == null ) {
|
| 73 |
this.parameters.setGeometryType(Geometry.TYPES.GEOMETRY); |
|
| 74 |
this.parameters.setGeometrySubtype(Geometry.SUBTYPES.GEOM2D); |
|
| 73 |
this.parameters.setTargetGeometryType(Geometry.TYPES.GEOMETRY);
|
|
| 74 |
this.parameters.setTargetGeometrySubtype(Geometry.SUBTYPES.GEOM2D);
|
|
| 75 | 75 |
} else {
|
| 76 | 76 |
GeometryType gt = geomDescriptor.getGeomType(); |
| 77 |
this.parameters.setGeometryType(gt.getType()); |
|
| 78 |
this.parameters.setGeometrySubtype(gt.getSubType()); |
|
| 77 |
this.parameters.setTargetGeometryType(gt.getType());
|
|
| 78 |
this.parameters.setTargetGeometrySubtype(gt.getSubType());
|
|
| 79 | 79 |
} |
| 80 | 80 |
|
| 81 | 81 |
if( ArrayUtils.isEmpty(this.geometryTypes) ) {
|
| ... | ... | |
| 220 | 220 |
public void exitPanel() {
|
| 221 | 221 |
Integer n = (Integer) ListElement.getSelected(cboType); |
| 222 | 222 |
if( n!=null ) {
|
| 223 |
this.parameters.setGeometryType(n); |
|
| 223 |
this.parameters.setTargetGeometryType(n);
|
|
| 224 | 224 |
} |
| 225 | 225 |
n = (Integer) ListElement.getSelected(cboSubtype); |
| 226 | 226 |
if( n!=null ) {
|
| 227 |
this.parameters.setGeometrySubtype(n); |
|
| 227 |
this.parameters.setTargetGeometrySubtype(n);
|
|
| 228 | 228 |
} |
| 229 | 229 |
} |
| 230 | 230 |
|
| 231 | 231 |
@Override |
| 232 | 232 |
public void enterPanel() {
|
| 233 | 233 |
if( this.updateComponents ) {
|
| 234 |
ListElement.setSelected(cboType, this.parameters.getGeometryTypeAsInt()); |
|
| 235 |
ListElement.setSelected(cboSubtype, this.parameters.getGeometrySubtype()); |
|
| 234 |
ListElement.setSelected(cboType, this.parameters.getTargetGeometryTypeAsInt());
|
|
| 235 |
ListElement.setSelected(cboSubtype, this.parameters.getTargetGeometrySubtype());
|
|
| 236 | 236 |
} |
| 237 | 237 |
this.updateComponents=false; |
| 238 | 238 |
} |
| trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.exportto/org.gvsig.exportto.swing/org.gvsig.exportto.swing.impl/src/main/java/org/gvsig/export/swing/impl/panels/SelectGeometryFieldPanel.java | ||
|---|---|---|
| 39 | 39 |
this.parameters = (ExportParametersGeometry) parameters; |
| 40 | 40 |
|
| 41 | 41 |
if( this.parameters.getSourceFeatureType().getDefaultGeometryAttribute()==null ) {
|
| 42 |
this.parameters.setGeometryFieldName(null); |
|
| 42 |
this.parameters.setSourceGeometryFieldName(null);
|
|
| 43 | 43 |
} else {
|
| 44 |
this.parameters.setGeometryFieldName(this.parameters.getSourceFeatureType().getDefaultGeometryAttributeName()); |
|
| 44 |
this.parameters.setSourceGeometryFieldName(this.parameters.getSourceFeatureType().getDefaultGeometryAttributeName());
|
|
| 45 | 45 |
} |
| 46 | 46 |
|
| 47 | 47 |
this.initComponents(); |
| ... | ... | |
| 65 | 65 |
|
| 66 | 66 |
@Override |
| 67 | 67 |
public void exitPanel() {
|
| 68 |
this.parameters.setGeometryFieldName(this.getGeometryField()); |
|
| 68 |
this.parameters.setSourceGeometryFieldName(this.getGeometryField());
|
|
| 69 | 69 |
} |
| 70 | 70 |
|
| 71 | 71 |
@Override |
| ... | ... | |
| 82 | 82 |
this.rdoSelectTheFieldToBeUsedAsGeometry.setEnabled(true); |
| 83 | 83 |
this.rdoSelectTheFieldToBeUsedAsGeometry.setSelected(false); |
| 84 | 84 |
|
| 85 |
if( this.parameters.getGeometryFieldName()==null ) {
|
|
| 85 |
if( this.parameters.getSourceGeometryFieldName()==null ) {
|
|
| 86 | 86 |
this.rdoUseTheGeometryFieldByDefault.setEnabled(false); |
| 87 | 87 |
this.rdoUseTheGeometryFieldByDefault.setSelected(false); |
| 88 | 88 |
this.rdoUseNullAsTheValueOfTheGeometry.setSelected(true); |
| trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.exportto/org.gvsig.exportto.swing/org.gvsig.exportto.swing.impl/src/main/java/org/gvsig/export/swing/impl/panels/CheckGeometriesPanel.java | ||
|---|---|---|
| 155 | 155 |
this.chkTryFixGeometry.setSelected( this.parameters.getTryToFixGeometry() ); |
| 156 | 156 |
} |
| 157 | 157 |
this.updateComponents = false; |
| 158 |
if( this.parameters.getGeometryFieldName()==null ) {
|
|
| 158 |
if( this.parameters.getSourceGeometryFieldName()==null ) {
|
|
| 159 | 159 |
this.rdbCheckIsCorrupt.setEnabled(false); |
| 160 | 160 |
this.rdbCheckIsValid.setEnabled(false); |
| 161 | 161 |
this.rdbCheckNone.setEnabled(false); |
| trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.exportto/org.gvsig.exportto.swing/org.gvsig.exportto.swing.prov/org.gvsig.exportto.swing.prov.shape/src/main/java/org/gvsig/export/shape/service/ExportShapeParametersImpl.java | ||
|---|---|---|
| 1 | 1 |
package org.gvsig.export.shape.service; |
| 2 | 2 |
|
| 3 | 3 |
import java.io.File; |
| 4 |
import org.apache.commons.io.FilenameUtils; |
|
| 4 | 5 |
import org.gvsig.export.spi.AbstractExportParametersGeometry; |
| 5 | 6 |
|
| 6 | 7 |
/** |
| ... | ... | |
| 36 | 37 |
|
| 37 | 38 |
@Override |
| 38 | 39 |
public void setFile(File file) {
|
| 39 |
this.file = file;
|
|
| 40 |
this.file = new File(FilenameUtils.removeExtension(file.getAbsolutePath()) + ".shp");
|
|
| 40 | 41 |
} |
| 41 | 42 |
|
| 42 | 43 |
} |
| trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.exportto/org.gvsig.exportto.swing/org.gvsig.exportto.swing.prov/org.gvsig.exportto.swing.prov.shape/src/main/java/org/gvsig/export/shape/service/ExportShapeService.java | ||
|---|---|---|
| 130 | 130 |
// Volvemos a obtener una copia "limpia" con los cambios consolidados |
| 131 | 131 |
ft = eft.getNotEditableCopy(); |
| 132 | 132 |
} |
| 133 |
|
|
| 134 |
// FIXME: check if ft has one and only one geometry. |
|
| 135 |
|
|
| 133 | 136 |
newStoreParameters.setDefaultFeatureType(ft.getEditable()); |
| 134 | 137 |
return newStoreParameters; |
| 135 | 138 |
} catch (DataException ex) {
|
| ... | ... | |
| 162 | 165 |
File parametersFile = this.getParameters().getFile(); |
| 163 | 166 |
String pathName = FilenameUtils.removeExtension(parametersFile.getAbsolutePath()); |
| 164 | 167 |
|
| 165 |
int geometryType = this.getParameters().getGeometryTypeAsInt(); |
|
| 168 |
int geometryType = this.getParameters().getTargetGeometryTypeAsInt();
|
|
| 166 | 169 |
|
| 167 | 170 |
if (geometryType == Geometry.TYPES.GEOMETRY) {
|
| 168 | 171 |
try {
|
| ... | ... | |
| 214 | 217 |
try {
|
| 215 | 218 |
EditableFeatureType type = this.getParameters().getSourceFeatureType().getCopy().getEditable(); |
| 216 | 219 |
|
| 217 |
String geomFieldName = this.getParameters().getGeometryFieldName(); |
|
| 220 |
String geomFieldName = this.getParameters().getSourceGeometryFieldName();
|
|
| 218 | 221 |
|
| 219 | 222 |
FeatureAttributeDescriptor geomFieldDescSource = (FeatureAttributeDescriptor) type.getDefaultGeometryAttribute(); |
| 220 | 223 |
if( geomFieldDescSource!=null ) {
|
| ... | ... | |
| 222 | 225 |
} |
| 223 | 226 |
EditableFeatureAttributeDescriptor geomFieldDescTarget = type.add( |
| 224 | 227 |
"GEOMETRY", |
| 225 |
this.getParameters().getGeometryTypeAsInt() |
|
| 228 |
this.getParameters().getTargetGeometryTypeAsInt()
|
|
| 226 | 229 |
); |
| 227 | 230 |
geomFieldDescTarget.setDefaultValue(null); |
| 228 |
int gsubtype = this.getParameters().getGeometrySubtype(); |
|
| 231 |
int gsubtype = this.getParameters().getTargetGeometrySubtype();
|
|
| 229 | 232 |
// El shp solo soporta los subtipos 2D y 3D |
| 230 | 233 |
switch (gsubtype) {
|
| 231 | 234 |
case Geometry.SUBTYPES.GEOM2D: |
| trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.exportto/org.gvsig.exportto.swing/org.gvsig.exportto.swing.prov/org.gvsig.exportto.swing.prov.jdbc/src/main/java/org/gvsig/export/jdbc/service/ExportJDBCService.java | ||
|---|---|---|
| 66 | 66 |
implements ExportService |
| 67 | 67 |
{
|
| 68 | 68 |
|
| 69 |
private static class InvalidGeometryException extends ExportException {
|
|
| 70 |
|
|
| 71 |
public InvalidGeometryException(Feature feature, String checkMessage) {
|
|
| 72 |
super(checkMessage, feature); |
|
| 73 |
} |
|
| 74 |
} |
|
| 75 |
|
|
| 76 | 69 |
private FeatureType targetFeatureType; |
| 77 | 70 |
|
| 78 | 71 |
|
| trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.exportto/org.gvsig.exportto.swing/org.gvsig.exportto.swing.prov/org.gvsig.exportto.swing.prov.dbf/src/main/java/org/gvsig/export/dbf/service/ExportDBFService.java | ||
|---|---|---|
| 121 | 121 |
// Volvemos a obtener una copia "limpia" con los cambios consolidados |
| 122 | 122 |
ft = eft.getNotEditableCopy(); |
| 123 | 123 |
} |
| 124 |
|
|
| 125 |
// FIXME: check types of fields in ft (remove Geometry?) |
|
| 126 |
|
|
| 124 | 127 |
newStoreParameters.setDefaultFeatureType(ft.getEditable()); |
| 125 | 128 |
return newStoreParameters; |
| 126 | 129 |
} catch (DataException ex) {
|
Also available in: Unified diff