diff --git a/src/main/java/org/apache/maven/shared/artifact/filter/PatternExcludesArtifactFilter.java b/src/main/java/org/apache/maven/shared/artifact/filter/PatternExcludesArtifactFilter.java
index b0d82ae..0dddb7b 100644
--- a/src/main/java/org/apache/maven/shared/artifact/filter/PatternExcludesArtifactFilter.java
+++ b/src/main/java/org/apache/maven/shared/artifact/filter/PatternExcludesArtifactFilter.java
@@ -19,7 +19,7 @@
  * under the License.
  */
 
-import java.util.List;
+import java.util.Collection;
 
 import org.apache.maven.artifact.Artifact;
 
@@ -32,12 +32,12 @@
 public class PatternExcludesArtifactFilter
     extends PatternIncludesArtifactFilter
 {
-    public PatternExcludesArtifactFilter( List<String> patterns )
+    public PatternExcludesArtifactFilter( Collection<String> patterns )
     {
         super( patterns );
     }
 
-    public PatternExcludesArtifactFilter( List<String> patterns, boolean actTransitively )
+    public PatternExcludesArtifactFilter( Collection<String> patterns, boolean actTransitively )
     {
         super( patterns, actTransitively );
     }
diff --git a/src/main/java/org/apache/maven/shared/artifact/filter/PatternIncludesArtifactFilter.java b/src/main/java/org/apache/maven/shared/artifact/filter/PatternIncludesArtifactFilter.java
index e8bf919..0f33982 100644
--- a/src/main/java/org/apache/maven/shared/artifact/filter/PatternIncludesArtifactFilter.java
+++ b/src/main/java/org/apache/maven/shared/artifact/filter/PatternIncludesArtifactFilter.java
@@ -20,6 +20,7 @@
  */
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -51,12 +52,12 @@
 
     private final List<String> filteredArtifactIds = new ArrayList<String>();
 
-    public PatternIncludesArtifactFilter( final List<String> patterns )
+    public PatternIncludesArtifactFilter( final Collection<String> patterns )
     {
         this( patterns, false );
     }
 
-    public PatternIncludesArtifactFilter( final List<String> patterns, final boolean actTransitively )
+    public PatternIncludesArtifactFilter( final Collection<String> patterns, final boolean actTransitively )
     {
         this.actTransitively = actTransitively;
         final List<String> pos = new ArrayList<String>();
diff --git a/src/main/java/org/apache/maven/shared/artifact/filter/resolve/transform/ArtifactIncludeFilterTransformer.java b/src/main/java/org/apache/maven/shared/artifact/filter/resolve/transform/ArtifactIncludeFilterTransformer.java
new file mode 100644
index 0000000..a4ccace
--- /dev/null
+++ b/src/main/java/org/apache/maven/shared/artifact/filter/resolve/transform/ArtifactIncludeFilterTransformer.java
@@ -0,0 +1,151 @@
+package org.apache.maven.shared.artifact.filter.resolve.transform;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import org.apache.maven.artifact.Artifact;
+import org.apache.maven.artifact.resolver.filter.AndArtifactFilter;
+import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
+import org.apache.maven.artifact.resolver.filter.ExcludesArtifactFilter;
+import org.apache.maven.shared.artifact.filter.PatternExcludesArtifactFilter;
+import org.apache.maven.shared.artifact.filter.PatternIncludesArtifactFilter;
+import org.apache.maven.shared.artifact.filter.resolve.AbstractFilter;
+import org.apache.maven.shared.artifact.filter.resolve.AndFilter;
+import org.apache.maven.shared.artifact.filter.resolve.ExclusionsFilter;
+import org.apache.maven.shared.artifact.filter.resolve.FilterTransformer;
+import org.apache.maven.shared.artifact.filter.resolve.OrFilter;
+import org.apache.maven.shared.artifact.filter.resolve.PatternExclusionsFilter;
+import org.apache.maven.shared.artifact.filter.resolve.PatternInclusionsFilter;
+import org.apache.maven.shared.artifact.filter.resolve.ScopeFilter;
+import org.apache.maven.shared.artifact.filter.resolve.TransformableFilter;
+
+/**
+ * Makes it possible to use the TransformableFilters for Aether and as classic Maven ArtifactFilter. 
+ * 
+ * <strong>Note:</strong> the {@link AndFilter} and {@link ExclusionsFilter} are transformed to {@link ArtifactFilter}
+ * implementations of Maven Core
+ * 
+ * @author Robert Scholte
+ * @since 3.0
+ */
+public class ArtifactIncludeFilterTransformer implements FilterTransformer<ArtifactFilter>
+{
+
+    @Override
+    public ArtifactFilter transform( final ScopeFilter scopeFilter )
+    {
+        return new ArtifactFilter()
+        {
+            @Override
+            public boolean include( Artifact artifact )
+            {
+                boolean isIncluded;
+                
+                if ( scopeFilter.getIncluded() != null )
+                {
+                    isIncluded = scopeFilter.getIncluded().contains( artifact.getScope() );
+                }
+                else
+                {
+                    isIncluded = true;
+                }
+                
+                boolean isExcluded;
+
+                if ( scopeFilter.getExcluded() != null )
+                {
+                    isExcluded = scopeFilter.getExcluded().contains( artifact.getScope() ); 
+                }
+                else
+                {
+                    isExcluded = false;
+                }
+
+                return isIncluded && !isExcluded;
+            }
+        };
+    }
+
+    @Override
+    public AndArtifactFilter transform( AndFilter andFilter )
+    {
+        AndArtifactFilter filter = new AndArtifactFilter();
+
+        for ( TransformableFilter subFilter : andFilter.getFilters() )
+        {
+            filter.add( subFilter.transform( this ) );
+        }
+
+        return filter;
+    }
+
+    @Override
+    public ArtifactFilter transform( final ExclusionsFilter exclusionsFilter )
+    {
+        return new ExcludesArtifactFilter( new ArrayList<String>( exclusionsFilter.getExcludes() ) );
+    }
+
+    @Override
+    public ArtifactFilter transform( OrFilter orFilter )
+    {
+        final Collection<ArtifactFilter> filters = new ArrayList<ArtifactFilter>( orFilter.getFilters().size() );
+
+        for ( TransformableFilter subFilter : orFilter.getFilters() )
+        {
+            filters.add( subFilter.transform( this ) );
+        }
+
+        return new ArtifactFilter()
+        {
+            @Override
+            public boolean include( Artifact artifact )
+            {
+                for ( ArtifactFilter filter : filters )
+                {
+                    if ( filter.include( artifact ) )
+                    {
+                        return true;
+                    }
+                }
+                return false;
+            }
+        };
+    }
+
+    @Override
+    public ArtifactFilter transform( PatternExclusionsFilter patternExclusionsFilter )
+    {
+        return new PatternExcludesArtifactFilter( patternExclusionsFilter.getExcludes() );
+    }
+
+    @Override
+    public ArtifactFilter transform( PatternInclusionsFilter patternInclusionsFilter )
+    {
+        return new PatternIncludesArtifactFilter( patternInclusionsFilter.getIncludes() );
+    }
+
+    @Override
+    public ArtifactFilter transform( final AbstractFilter filter )
+    {
+        throw new UnsupportedOperationException( "Not yet implemented" );
+    }
+}
diff --git a/src/test/java/org/apache/maven/shared/artifact/filter/resolve/transform/ArtifactIncludeFilterTransformerTest.java b/src/test/java/org/apache/maven/shared/artifact/filter/resolve/transform/ArtifactIncludeFilterTransformerTest.java
new file mode 100644
index 0000000..fe3e2fe
--- /dev/null
+++ b/src/test/java/org/apache/maven/shared/artifact/filter/resolve/transform/ArtifactIncludeFilterTransformerTest.java
@@ -0,0 +1,162 @@
+package org.apache.maven.shared.artifact.filter.resolve.transform;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import static org.junit.Assert.*;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+import org.apache.maven.artifact.Artifact;
+import org.apache.maven.artifact.factory.ArtifactFactory;
+import org.apache.maven.artifact.resolver.filter.AndArtifactFilter;
+import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
+import org.apache.maven.artifact.resolver.filter.ScopeArtifactFilter;
+import org.apache.maven.plugin.testing.ArtifactStubFactory;
+import org.apache.maven.plugin.testing.stubs.ArtifactStub;
+import org.apache.maven.plugin.testing.stubs.StubArtifactRepository;
+import org.apache.maven.shared.artifact.filter.PatternExcludesArtifactFilter;
+import org.apache.maven.shared.artifact.filter.PatternIncludesArtifactFilter;
+import org.apache.maven.shared.artifact.filter.resolve.AndFilter;
+import org.apache.maven.shared.artifact.filter.resolve.ExclusionsFilter;
+import org.apache.maven.shared.artifact.filter.resolve.OrFilter;
+import org.apache.maven.shared.artifact.filter.resolve.PatternExclusionsFilter;
+import org.apache.maven.shared.artifact.filter.resolve.PatternInclusionsFilter;
+import org.apache.maven.shared.artifact.filter.resolve.ScopeFilter;
+import org.apache.maven.shared.artifact.filter.resolve.TransformableFilter;
+import org.eclipse.aether.artifact.DefaultArtifact;
+import org.eclipse.aether.graph.DefaultDependencyNode;
+import org.eclipse.aether.graph.Dependency;
+import org.eclipse.aether.graph.DependencyNode;
+import org.eclipse.aether.util.filter.AndDependencyFilter;
+import org.eclipse.aether.util.filter.ExclusionsDependencyFilter;
+import org.eclipse.aether.util.filter.OrDependencyFilter;
+import org.eclipse.aether.util.filter.PatternExclusionsDependencyFilter;
+import org.eclipse.aether.util.filter.PatternInclusionsDependencyFilter;
+import org.eclipse.aether.util.filter.ScopeDependencyFilter;
+import org.junit.Ignore;
+import org.junit.Test;
+
+public class ArtifactIncludeFilterTransformerTest
+{
+
+    private ArtifactIncludeFilterTransformer transformer = new ArtifactIncludeFilterTransformer();
+
+    private ArtifactStubFactory artifactFactory = new ArtifactStubFactory();
+
+    @Test
+    public void testTransformAndFilter()
+        throws Exception
+    {
+        AndFilter filter =
+            new AndFilter(
+                           Arrays.<TransformableFilter>asList( ScopeFilter.including( "compile" ),
+                                                        new ExclusionsFilter( Collections.singletonList( "x:a" ) ) ) );
+
+        AndArtifactFilter dependencyFilter = (AndArtifactFilter) filter.transform( transformer );
+
+        assertTrue( dependencyFilter.include( newArtifact( "g:a:v", "compile" ) ) );
+
+        assertFalse( dependencyFilter.include( newArtifact( "x:a:v", "compile" ) ) );
+
+        assertFalse( dependencyFilter.include( newArtifact( "g:a:v", "test" ) ) );
+
+        assertFalse( dependencyFilter.include( newArtifact( "x:a:v", "test" ) ) );
+    }
+
+    @Test
+    public void testTransformExclusionsFilter()
+        throws Exception
+    {
+        ExclusionsFilter filter = new ExclusionsFilter( Collections.singletonList( "x:a" ) );
+
+        ArtifactFilter dependencyFilter = (ArtifactFilter) filter.transform( transformer );
+
+        assertTrue( dependencyFilter.include( newArtifact( "g:a:v", "compile" ) ) );
+
+        assertFalse( dependencyFilter.include( newArtifact( "x:a:v", "compile" ) ) );
+    }
+
+    @Test
+    public void testTransformOrFilter()
+        throws Exception
+    {
+        OrFilter filter =
+            new OrFilter( Arrays.<TransformableFilter>asList( ScopeFilter.including( "compile" ),
+                                                              ScopeFilter.including( "test" ) ) );
+
+        ArtifactFilter dependencyFilter = (ArtifactFilter) filter.transform( transformer );
+
+        assertTrue( dependencyFilter.include( newArtifact( "g:a:v", "compile" ) ) );
+
+        assertTrue( dependencyFilter.include( newArtifact( "g:a:v", "test" ) ) );
+
+        assertFalse( dependencyFilter.include( newArtifact( "g:a:v", "runtime" ) ) );
+    }
+
+    @Test
+    public void testTransformScopeFilter()
+        throws Exception
+    {
+        ScopeFilter filter = ScopeFilter.including( Collections.singletonList( "runtime" ) );
+
+        ArtifactFilter dependencyFilter = (ArtifactFilter) filter.transform( transformer );
+
+        assertTrue( dependencyFilter.include( newArtifact( "g:a:v", "runtime" ) ) );
+
+        assertFalse( dependencyFilter.include( newArtifact( "g:a:v", "compile" ) ) );
+
+        assertFalse( dependencyFilter.include( newArtifact( "g:a:v", "test" ) ) );
+    }
+
+    @Test
+    public void testTransformPatternExclusionsFilter()
+        throws Exception
+    {
+        PatternExclusionsFilter filter = new PatternExclusionsFilter( Collections.singletonList( "x:*" ) );
+
+        PatternExcludesArtifactFilter dependencyFilter = (PatternExcludesArtifactFilter) filter.transform( transformer );
+
+        assertTrue( dependencyFilter.include( newArtifact( "g:a:v", "runtime" ) ) );
+
+        assertFalse( dependencyFilter.include( newArtifact( "x:a:v", "runtime" ) ) );
+    }
+
+    @Test
+    public void testTransformPatternInclusionsFilter()
+        throws Exception
+    {
+        PatternInclusionsFilter filter = new PatternInclusionsFilter( Collections.singletonList( "g:*" ) );
+
+        PatternIncludesArtifactFilter dependencyFilter = (PatternIncludesArtifactFilter) filter.transform( transformer );
+
+        assertTrue( dependencyFilter.include( newArtifact( "g:a:v", "runtime" ) ) );
+
+        assertFalse( dependencyFilter.include( newArtifact( "x:a:v", "runtime" ) ) );
+    }
+
+    private Artifact newArtifact( String coor, String scope )
+        throws Exception
+    {
+        String[] gav = coor.split( ":" );
+        return artifactFactory.createArtifact( gav[0], gav[1], gav[2], scope );
+    }
+
+}