matplotlib-users Mailing List for matplotlib

On Fri, Dec 9, 2011 at 5:23 PM, Tony Yu <ts...@gm...> wrote:
>
>
> On Fri, Dec 9, 2011 at 4:11 PM, Daniel Hyams <dh...@gm...> wrote:
>
>> I'm sorry, I should have stated the version. I'm using 1.0.0, which just
>> returns a list of rectangle artists.
>>
>>
>> On Fri, Dec 9, 2011 at 4:08 PM, Benjamin Root <ben...@ou...> wrote:
>>
>>> On Fri, Dec 9, 2011 at 2:55 PM, Daniel Hyams <dh...@gm...> wrote:
>>>
>>>> Tried, but unfortunately it did not make any difference :(
>>>>
>>>>
>>> Just as an interesting point... don't know if it means anything. In
>>> v1.1.x, we now return a "BarContainer" from the bar() function. This
>>> container subclasses the tuple type, which is why you are still able to
>>> treat it like a list. Anyway, this class does a bunch of things that I
>>> wonder if it could be interfering with what you are trying to do. Probably
>>> not, but still...
>>>
>>> Ben Root
>>>
>>>
>>
>>
>> --
>> Daniel Hyams
>> dh...@gm...
>>
>
> So I think the problem is that ``plt.bar`` assigns a transform to each
> patch (as it should). But then when pass these patches to PatchCollection,
> the collection applies it's own transform (but doesn't ignore the patch's
> transform, apparently). The solution is to clear out the transform on each
> patch---where "clearing" a transform translates to setting it to the
> IdentityTransform.
>
> Below is code that works *on my system*. It sounds like it will work
> slightly differently on your system:
>
>
> #!/usr/bin/env python
> import numpy
> import matplotlib.pyplot as plt
> import matplotlib.collections
> import matplotlib.transforms as transforms
>
>
> # just generate some data to plot
> x = numpy.linspace(0.0,2.0*numpy.pi,10)
> y = numpy.sin(x)
>
> # plot
> axes = plt.gca()
> bars = plt.bar(x,y,color='red',width=0.1)
>
> axes.patches = []
> for p in bars.patches:
> p.set_transform(transforms.IdentityTransform())
>
> ## and create a collection for plotting the rectangles instead.
> coll = matplotlib.collections.PatchCollection(bars.patches)
>
> coll.set_transform(axes.transData)
> axes.add_collection(coll, autolim=True)
>
> plt.xlim(0.0,2.0*numpy.pi)
> plt.grid(True)
> plt.show()
>
>
>
P.S. you don't need the call to set_transform that I accidentally added.

On Fri, Dec 9, 2011 at 4:11 PM, Daniel Hyams <dh...@gm...> wrote:
> I'm sorry, I should have stated the version. I'm using 1.0.0, which just
> returns a list of rectangle artists.
>
>
> On Fri, Dec 9, 2011 at 4:08 PM, Benjamin Root <ben...@ou...> wrote:
>
>> On Fri, Dec 9, 2011 at 2:55 PM, Daniel Hyams <dh...@gm...> wrote:
>>
>>> Tried, but unfortunately it did not make any difference :(
>>>
>>>
>> Just as an interesting point... don't know if it means anything. In
>> v1.1.x, we now return a "BarContainer" from the bar() function. This
>> container subclasses the tuple type, which is why you are still able to
>> treat it like a list. Anyway, this class does a bunch of things that I
>> wonder if it could be interfering with what you are trying to do. Probably
>> not, but still...
>>
>> Ben Root
>>
>>
>
>
> --
> Daniel Hyams
> dh...@gm...
>
So I think the problem is that ``plt.bar`` assigns a transform to each
patch (as it should). But then when pass these patches to PatchCollection,
the collection applies it's own transform (but doesn't ignore the patch's
transform, apparently). The solution is to clear out the transform on each
patch---where "clearing" a transform translates to setting it to the
IdentityTransform.
Below is code that works *on my system*. It sounds like it will work
slightly differently on your system:
#!/usr/bin/env python
import numpy
import matplotlib.pyplot as plt
import matplotlib.collections
import matplotlib.transforms as transforms
# just generate some data to plot
x = numpy.linspace(0.0,2.0*numpy.pi,10)
y = numpy.sin(x)
# plot
axes = plt.gca()
bars = plt.bar(x,y,color='red',width=0.1)
axes.patches = []
for p in bars.patches:
 p.set_transform(transforms.IdentityTransform())
## and create a collection for plotting the rectangles instead.
coll = matplotlib.collections.PatchCollection(bars.patches)
coll.set_transform(axes.transData)
axes.add_collection(coll, autolim=True)
plt.xlim(0.0,2.0*numpy.pi)
plt.grid(True)
plt.show()

I'm sorry, I should have stated the version. I'm using 1.0.0, which just
returns a list of rectangle artists.
On Fri, Dec 9, 2011 at 4:08 PM, Benjamin Root <ben...@ou...> wrote:
> On Fri, Dec 9, 2011 at 2:55 PM, Daniel Hyams <dh...@gm...> wrote:
>
>> Tried, but unfortunately it did not make any difference :(
>>
>>
> Just as an interesting point... don't know if it means anything. In
> v1.1.x, we now return a "BarContainer" from the bar() function. This
> container subclasses the tuple type, which is why you are still able to
> treat it like a list. Anyway, this class does a bunch of things that I
> wonder if it could be interfering with what you are trying to do. Probably
> not, but still...
>
> Ben Root
>
>
-- 
Daniel Hyams
dh...@gm...

On Fri, Dec 9, 2011 at 2:55 PM, Daniel Hyams <dh...@gm...> wrote:
> Tried, but unfortunately it did not make any difference :(
>
>
Just as an interesting point... don't know if it means anything. In
v1.1.x, we now return a "BarContainer" from the bar() function. This
container subclasses the tuple type, which is why you are still able to
treat it like a list. Anyway, this class does a bunch of things that I
wonder if it could be interfering with what you are trying to do. Probably
not, but still...
Ben Root

Tried, but unfortunately it did not make any difference :(
On Fri, Dec 9, 2011 at 2:22 PM, Tony Yu <ts...@gm...> wrote:
>
>
> On Fri, Dec 9, 2011 at 2:13 PM, Daniel Hyams <dh...@gm...> wrote:
>
>> I can't tell if I'm misusing collections here, or if there is a bug.
>> Anyway, what I'm trying to do is keep track of a group of rectangles
>> generated from a bar plot. Instead of letting there be a large number of
>> artists added to the axes, I wanted to just group them into a collection
>> and add the collection instead. As in the code below:
>>
>> #!/usr/bin/env python
>> import numpy
>> import matplotlib.pyplot as plt
>> import matplotlib.collections
>>
>> # just generate some data to plot
>> x = numpy.linspace(0.0,2.0*numpy.pi,10)
>> y = numpy.sin(x)
>>
>> # plot
>> axes = plt.gca()
>> bars = plt.bar(x,y,color='red',width=0.1)
>>
>> # strip out all of the newly inserted rectangles
>> for b in bars: b.remove()
>>
>> # and create a collection for plotting the rectangles instead.
>> coll = matplotlib.collections.PatchCollection(bars)
>>
>> axes.artists.append(coll)
>>
>> plt.xlim(0.0,2.0*numpy.pi)
>> plt.grid(True)
>> plt.show()
>>
>> This appears to work at first blush, but if you resize the plot, you can
>> tell that the rectangles are just fixed in their location now. I tried
>> messing around with setting the transform for the new collection object
>> "coll" in different ways, to no avail. Any suggestions welcome ;)
>>
>> --
>> Daniel Hyams
>> dh...@gm...
>>
>> try transOffset:
>
> >>> coll = matplotlib.collections.PatchCollection(bars,
> transOffset=axes.transData)
>
> I've always found this a bit clumsy, but I think it's the standard way to
> do it.
>
> -Tony
>
-- 
Daniel Hyams
dh...@gm...

On Fri, Dec 9, 2011 at 2:13 PM, Daniel Hyams <dh...@gm...> wrote:
> I can't tell if I'm misusing collections here, or if there is a bug.
> Anyway, what I'm trying to do is keep track of a group of rectangles
> generated from a bar plot. Instead of letting there be a large number of
> artists added to the axes, I wanted to just group them into a collection
> and add the collection instead. As in the code below:
>
> #!/usr/bin/env python
> import numpy
> import matplotlib.pyplot as plt
> import matplotlib.collections
>
> # just generate some data to plot
> x = numpy.linspace(0.0,2.0*numpy.pi,10)
> y = numpy.sin(x)
>
> # plot
> axes = plt.gca()
> bars = plt.bar(x,y,color='red',width=0.1)
>
> # strip out all of the newly inserted rectangles
> for b in bars: b.remove()
>
> # and create a collection for plotting the rectangles instead.
> coll = matplotlib.collections.PatchCollection(bars)
>
> axes.artists.append(coll)
>
> plt.xlim(0.0,2.0*numpy.pi)
> plt.grid(True)
> plt.show()
>
> This appears to work at first blush, but if you resize the plot, you can
> tell that the rectangles are just fixed in their location now. I tried
> messing around with setting the transform for the new collection object
> "coll" in different ways, to no avail. Any suggestions welcome ;)
>
> --
> Daniel Hyams
> dh...@gm...
>
> try transOffset:
>>> coll = matplotlib.collections.PatchCollection(bars,
transOffset=axes.transData)
I've always found this a bit clumsy, but I think it's the standard way to
do it.
-Tony

I can't tell if I'm misusing collections here, or if there is a bug.
 Anyway, what I'm trying to do is keep track of a group of rectangles
generated from a bar plot. Instead of letting there be a large number of
artists added to the axes, I wanted to just group them into a collection
and add the collection instead. As in the code below:
#!/usr/bin/env python
import numpy
import matplotlib.pyplot as plt
import matplotlib.collections
# just generate some data to plot
x = numpy.linspace(0.0,2.0*numpy.pi,10)
y = numpy.sin(x)
# plot
axes = plt.gca()
bars = plt.bar(x,y,color='red',width=0.1)
# strip out all of the newly inserted rectangles
for b in bars: b.remove()
# and create a collection for plotting the rectangles instead.
coll = matplotlib.collections.PatchCollection(bars)
axes.artists.append(coll)
plt.xlim(0.0,2.0*numpy.pi)
plt.grid(True)
plt.show()
This appears to work at first blush, but if you resize the plot, you can
tell that the rectangles are just fixed in their location now. I tried
messing around with setting the transform for the new collection object
"coll" in different ways, to no avail. Any suggestions welcome ;)
-- 
Daniel Hyams
dh...@gm...

On Friday, December 9, 2011, Laat de, Jos (KNMI) <jos...@kn...>
wrote:
> I am working with (geostationary) satellite data, and one of the things I
want to do is plot a map (coastlines) on top of the satellite image. As an
IDL user I know how to do this in IDL (although in IDL it is a bit of a
hassle), but I don’t seem to be able to figure out how this could be done
in python.
>
>
>
> The satellite data consists of a rectangular field of N by N pixels. The
data is already converted to bitmap RGB values. I have figured out how this
can be written to a bitmap image like PNG or JPG.
>
>
>
> I further figured out how to do the satellite projection in Basemap, and
how to plot Basemap coastlines. However, the Basemap appears to have a
non-transparent background, which overplots all bitmap data if I plot the
Bitmap data first. I had hoped that there would be some transparency
setting in Basemap, but alas.
>
>
>
> (ps. Keep in mind that I do not want to use some contour filling routine
for plotting the satellite data. I want to retain the original N x N pixels
and image size)
What commands are you using to plot the data? drawcoastlines() should only
draw lines. Maybe "hold" is being set to false in your matplotlibrc file
or in your code?
Ben Root

I am working with (geostationary) satellite data, and one of the things
I want to do is plot a map (coastlines) on top of the satellite image.
As an IDL user I know how to do this in IDL (although in IDL it is a bit
of a hassle), but I don't seem to be able to figure out how this could
be done in python.
 
The satellite data consists of a rectangular field of N by N pixels. The
data is already converted to bitmap RGB values. I have figured out how
this can be written to a bitmap image like PNG or JPG.
 
I further figured out how to do the satellite projection in Basemap, and
how to plot Basemap coastlines. However, the Basemap appears to have a
non-transparent background, which overplots all bitmap data if I plot
the Bitmap data first. I had hoped that there would be some transparency
setting in Basemap, but alas.
 
(ps. Keep in mind that I do not want to use some contour filling routine
for plotting the satellite data. I want to retain the original N x N
pixels and image size)