Jeff,

In fact my satellite data is displaying clouds of various gases, and I don’t
like the fact that "empty" places are left dark blue (I use jet reversed
cmap)

By masking data under a certain value, I isolate the clouds and then they
are in evidence

When I use vmin and vmax I'm able to avoid the colormap rescaling and I keep
the cloud's original colour, but then it is the colorbar which poses
problems, as there's a part of the bar that is useless

I guess what I should do is setting a new colorbar myself, but there again,
it is not very easy to understand... that kind of libraries are really
occult for a non-scientific IT graduate like me

Now for the antialiasing and interpolation, the thing I try to do is making
it look less pixeled, I don't need all the points to be interpolated, but
just make the existing points smoother to have a smooth, quality figure

You have helped me a lot, and I know my questions were beginners ones, so
I'll understand if you prefer giving some time to something more interesting

Antoine De Pauw
Collaborateur de recherches, Informatique - Research collaborator, IT
Laboratoire de chimie quantique et photophysique - Quantum chemistry and
photophysics laboratory
Université Libre de Bruxelles - ULB


-----Original Message-----
From: Jeff Whitaker [mailto:[EMAIL PROTECTED] 
Sent: mardi 16 septembre 2008 13:16
To: De Pauw Antoine
Cc: 'Matplotlib Users'
Subject: Re: [Matplotlib-users] Information request

De Pauw Antoine wrote:
> Hi Jeff,
>
> I have played a bit with Matplotlib since last week, and I may still have
> some questions for you
>
> I have masked my value array so it doesn't draw points under a certain
> value, but doing this causes the colormap to rescale for the new values
>   

Antoine:  Don't quite know what you're trying to accomplish, but you can 
use the vmin/vmax keywords to imshow, pcolor or scatter to scale the 
colormap to a certain range.  Also, take a look at the image_masked.py 
example to see how to set the 'over/under' color in a colormap.
> I have tried to set a custom colormap but it isn't the thing to do as data
> is varying in time
>
> So is it possible to avoid the colormap to rescale itself?
>
> Also, I had a look at imshow and the interpolation process is really
> interesting for smooth maps.. does a way to interpolate scattered data
> exist?
>   
If you have the most recent version of matplotlib you can use the 
griddata function to interpolate scattered data to a regular grid.

-Jeff
> The code I use didn't change since last time, all I did is adding a bit,
> testing and deleting..
>
> Best regards,
>
> Antoine De Pauw
> Collaborateur de recherches, Informatique - Research collaborator, IT
> Laboratoire de chimie quantique et photophysique - Quantum chemistry and
> photophysics laboratory
> Université Libre de Bruxelles - ULB
>
> -----Original Message-----
> From: Jeff Whitaker [mailto:[EMAIL PROTECTED] 
> Sent: vendredi 12 septembre 2008 13:26
> To: De Pauw Antoine
> Cc: 'Matplotlib Users'
> Subject: Re: [Matplotlib-users] Information request
>
> De Pauw Antoine wrote:
>   
>> Hi Jeff,
>>
>> I updated my code snippet and uploaded the image I created with a
complete
>> set of data:
>>
>> http://snipplr.com/view/8307/map-plotting-python-code-temporary/
>>
>> And here's the picture generated:
>>
>> http://www.kirikoo.net/images/5shrad-20080912-105759.png
>>
>> I now understand the process and I'm able to reproduce it for other
>> datasets, but I need to implement some antialiasing for it..
>>
>> Is it possible to do?
>>
>> Many thanks for your precious help!
>>
>> Antoine De Pauw
>> Collaborateur de recherches, Informatique - Research collaborator, IT
>> Laboratoire de chimie quantique et photophysique - Quantum chemistry and
>> photophysics laboratory
>> Université Libre de Bruxelles - ULB
>>   
>>     
>
> Antoine:  If you do
>
>  >>> from pylab import scatter
>  >>> help(scatter)
>
> you will see that scatter takes an antialised keyword
>
>      antialiased    Boolean or sequence of booleans    
>
> -Jeff
>
>   
>> -----Original Message-----
>> From: Jeff Whitaker [mailto:[EMAIL PROTECTED] 
>> Sent: jeudi 11 septembre 2008 16:48
>> To: De Pauw Antoine
>> Cc: 'Matplotlib Users'
>> Subject: Re: [Matplotlib-users] Information request
>>
>> De Pauw Antoine wrote:
>>   
>>     
>>> Jeff,
>>>
>>> The map object is from the Basemap type, the only different thing is the
>>> Lon,Lat and Val objects which are from the type array instead of lists
>>>
>>> Anyway, solutions are slowly showing themselves and I thank you all
>>>
>>> Have a nice day
>>>
>>> Antoine De Pauw
>>> Collaborateur de recherches, Informatique - Research collaborator, IT
>>> Laboratoire de chimie quantique et photophysique - Quantum chemistry and
>>> photophysics laboratory
>>> Université Libre de Bruxelles - ULB
>>>   
>>>     
>>>       
>> Antoine:  It should not matter if Lon and Lat are python arrays, lists 
>> or numpy arrays.  The Basemap instance __call__ method handles them all. 
>> There must be something else going on.  It is always better to post 
>> actual code so we can see what is happening and test it ourselves.
>>
>> -Jeff
>>   
>>     
>>> -----Original Message-----
>>> From: Jeff Whitaker [mailto:[EMAIL PROTECTED] 
>>> Sent: jeudi 11 septembre 2008 15:29
>>> To: De Pauw Antoine
>>> Cc: 'Matplotlib Users'
>>> Subject: Re: [Matplotlib-users] Information request
>>>
>>> De Pauw Antoine wrote:
>>>   
>>>     
>>>       
>>>> Thanks Jeff,
>>>>
>>>> This seems to work with csv file types, and I've been experimenting a
>>>>         
> bit
>   
>>>> with it
>>>>
>>>> However, when I try to implement this with my original code (with
binary
>>>> files), I get an error like that one:
>>>>
>>>> Traceback (most recent call last):
>>>>   File "C:\Python25\Projects\FigPlot\FigPlot.py", line 39, in <module>
>>>>     x,y = map(Lon,Lat)
>>>> TypeError: 'numpy.ndarray' object is not callable
>>>>
>>>> I think this is coming from the fact I use array objects to store
>>>>     
>>>>       
>>>>         
>>> values...
>>>   
>>>     
>>>       
>>>> could you confirm it?
>>>>   
>>>>     
>>>>       
>>>>         
>>> Antoine:  It looks like you the object map is not a Basemap instance, 
>>> but a numpy array.  Try putting 'print type(map)' just ahead of this 
>>> statement to verify this. I suspect your re-using the name 'map' in your

>>> code,  overwriting the Basemap class instance.
>>>
>>> -Jeff
>>>   
>>>     
>>>       
>>>> Also, I'll see if it is possible to invert color scale and mask
>>>>       
>>>>         
>> everything
>>   
>>     
>>>> under a certain value
>>>>
>>>> Thanks very much for your help!
>>>>
>>>> Antoine De Pauw
>>>> Collaborateur de recherches, Informatique - Research collaborator, IT
>>>> Laboratoire de chimie quantique et photophysique - Quantum chemistry
and
>>>> photophysics laboratory
>>>> Université Libre de Bruxelles - ULB
>>>>
>>>>
>>>> -----Original Message-----
>>>> From: Jeff Whitaker [mailto:[EMAIL PROTECTED] 
>>>> Sent: jeudi 11 septembre 2008 14:10
>>>> To: De Pauw Antoine
>>>> Cc: 'Matplotlib Users'
>>>> Subject: Re: [Matplotlib-users] Information request
>>>>
>>>> De Pauw Antoine wrote:
>>>>   
>>>>     
>>>>       
>>>>         
>>>>> Hi Jeff,
>>>>>
>>>>> I have put the code online with a sample of the data here:
>>>>>
>>>>> http://snipplr.com/view/8307/map-plotting-python-code-temporary/
>>>>>
>>>>> I hope you'll be able to give me some advice as it is quite difficult
>>>>>         
>>>>>           
>> for
>>   
>>     
>>>>> someone new in python and scientific computation
>>>>>
>>>>> Antoine De Pauw
>>>>> Collaborateur de recherches, Informatique - Research collaborator, IT
>>>>> Laboratoire de chimie quantique et photophysique - Quantum chemistry
>>>>>           
> and
>   
>>>>> photophysics laboratory
>>>>> Université Libre de Bruxelles - ULB
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>> Antoine: I may have the size of the pixels wrong, and lat/lon 
>>>> transposed, but this is the general idea:
>>>>
>>>> from mpl_toolkits.basemap import Basemap
>>>> import matplotlib.pyplot as plt
>>>> import numpy as np
>>>> lats = []; lons = []; data = []
>>>> for line in open('pixels.dat'):
>>>>     linesplit = line.split(',')
>>>>     lons.append(float(linesplit[1]))
>>>>     lats.append(float(linesplit[0]))
>>>>     data.append(float(linesplit[2]))
>>>> map = 
>>>> Basemap(projection='mill',llcrnrlat=min(lats)-5,urcrnrlat=max(lats)+5,\
>>>>                           
>>>> urcrnrlon=max(lons)+5,llcrnrlon=min(lons)-5,resolution='l')
>>>> x,y = map(lons,lats)
>>>>
plt.scatter(x,y,s=25,c=data,marker='s',edgecolor="None",cmap=plt.cm.jet)
>>>> plt.colorbar(shrink=0.6)
>>>> map.drawcoastlines()
>>>> plt.show()
>>>>
>>>> -Jeff
>>>>
>>>>   
>>>>     
>>>>       
>>>>         
>>>>> -----Original Message-----
>>>>> From: Jeff Whitaker [mailto:[EMAIL PROTECTED] 
>>>>> Sent: mercredi 10 septembre 2008 16:45
>>>>> To: Antoine De Pauw
>>>>> Cc: Matplotlib Users
>>>>> Subject: Re: Information request
>>>>>
>>>>> Antoine De Pauw wrote:
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>> Thanks Jeff,
>>>>>>
>>>>>> In fact my points are arranged in three unsorted arrays, with a
simple
>>>>>>     
>>>>>>       
>>>>>>         
>>>>>>           
>>>>>>             
>>>>> scheme (thats why I couldn't plot them with imshow and others)
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>> arrays:
>>>>>>
>>>>>> [lat][lon][val]
>>>>>> [-10][ 17][0.3]
>>>>>> [ 37][ 23][3.7]
>>>>>>  ...  ...  ...
>>>>>>
>>>>>> and so for many rows...
>>>>>>
>>>>>> what I have to do is looping through my arrays like that
>>>>>>
>>>>>> while i < rowcount:
>>>>>>     plot_to_map(lat[i],lon[i],val[i])
>>>>>>
>>>>>> it is evidently an idea of how it could be done easily but my
>>>>>>             
> knowledge
>   
>>>>>>       
>>>>>>         
>>>>>>           
>>>>>>             
>>>> of
>>>>   
>>>>     
>>>>       
>>>>         
>>>>>>     
>>>>>>       
>>>>>>         
>>>>>>           
>>>>>>             
>>>>> these libraries is too weak for me to figure out how to do it
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>> my data comes from huge binary files but is extremely simple, so it
>>>>>>         
>>>>>>           
>>>>>>             
>>> would
>>>   
>>>     
>>>       
>>>>>>     
>>>>>>       
>>>>>>         
>>>>>>           
>>>>>>             
>>>>> be really easy for anyone to help me as the problem itself is how to
>>>>>           
> put
>   
>>>>> unsorted points on the map with latitude and longitude coordinates
>>>>>   
>>>>>
>>>>> Antoine:  You haven't said if your data forms a rectangular array.  If

>>>>> so, you can build a 2-d array from the input file and plot it with 
>>>>> imshow.  If not, you can still plug the elements into a 2-d masked 
>>>>> array, leaving the missing pixels masked.  You say the points are 
>>>>> 'unsorted', does that mean they are randomly distributed and do not
>>>>>           
> form
>   
>>>>>         
>>>>>           
>>   
>>     
>>>>> a rectangular grid?
>>>>>
>>>>> It would really be much easier to help if you gave us more
information,
>>>>>           
>
>   
>>>>> such as how the data is structured, what the pixel footprint is, etc. 
>>>>> Perhaps you could post the binary file on an ftp site somewhere with 
>>>>> code to read it.
>>>>>
>>>>> Also, please hit 'reply all' when replying, so the matplotlib users 
>>>>> mailing list is CC'ed.
>>>>>
>>>>> -Jeff
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>> Antoine De Pauw wrote:
>>>>>>>       
>>>>>>>         
>>>>>>>           
>>>>>>>             
>>>>>>>               
>>>>>>>> Sir,
>>>>>>>>
>>>>>>>> I'm sorry, as english is not my mothertongue and it is sometimes
>>>>>>>>         
>>>>>>>>           
>>>>>>>>             
>>>>>>>>               
>>>>>>>>                 
>>>>> difficult to be understandable.
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>> All is in the script I gave to you initially, except the point
>>>>>>>>               
>>>>>>>>                 
>> drawing
>>   
>>     
>>>>>>>>         
>>>>>>>>           
>>>>>>>>             
>>>>>>>>               
>>>>>>>>                 
>>>>> code which would be useless as it is proven not to work (I dont know
>>>>>           
> the
>   
>>>>> method to do it).
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>> What I have is a map, and a set of pixels I have to put on it with
>>>>>>>>         
>>>>>>>>           
>>>>>>>>             
>>>>>>>>               
>>>>>>>>                 
>>>>> geographic coordinates.
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>> I cannot find the right method to put colour pixels on the map,
>>>>>>>>               
>>>>>>>>                 
>> that's
>>   
>>     
>>>>>>>>         
>>>>>>>>           
>>>>>>>>             
>>>>>>>>               
>>>>>>>>                 
>>>>> the problem.
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>> I have that map in miller projection, and three arrays containing
>>>>>>>>         
>>>>>>>>           
>>>>>>>>             
>>>>>>>>               
>>>>>>>>                 
>>>>> respectively latitude, longitude and satellite measured value.
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>> What I need to obtain is something approximately like this:
>>>>>>>>         
>>>>>>>>           
>>>>>>>>             
>>>>>>>>               
>>>>>>>>                 
>
http://www.oma.be/BIRA-IASB/Molecules/SO2archive/info/background/so2sc200703
>   
>>   
>>     
>>>   
>>>     
>>>       
>>>>   
>>>>     
>>>>       
>>>>         
>>>>> _00_lr.gif but with the basemap toolkit.
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>> So, my question is: how could I do to plot a coloured pixel at
>>>>>>>>         
>>>>>>>>           
>>>>>>>>             
>>>>>>>>               
>>>>>>>>                 
>>>>> coordinates lat:lon on that map? If I have just the method to project
a
>>>>> geographic coordinate on the map and put a coloured pixel at the right
>>>>> place, all is done and I just have to loop my arrays... Also, I would
>>>>>       
>>>>>         
>>>>>           
>>> have
>>>   
>>>     
>>>       
>>>>> to implement some antialiasing on the map.
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>>   
>>>>>>>>         
>>>>>>>>           
>>>>>>>>             
>>>>>>>>               
>>>>>>>>                 
>>>>>>> Antoine:
>>>>>>>
>>>>>>> Are the pixels arranged on a regular grid - or are they randomly 
>>>>>>> distributed?  If they are on a grid, it's easy (using pcolor or
>>>>>>>           
>>>>>>>             
>>>>>>>               
>>> imshow).
>>>   
>>>     
>>>       
>>>>>>>         
>>>>>>>           
>>>>>>>             
>>>>>>>               
>>>>   
>>>>     
>>>>       
>>>>         
>>>>>>> If you could send me your data I may be able to get you started.
>>>>>>>
>>>>>>> (I'm cc'ing the matplotlib list so others can join in the
>>>>>>>               
> discussion).
>   
>>>>>>> -Jeff
>>>>>>>       
>>>>>>>         
>>>>>>>           
>>>>>>>             
>>>>>>>               
>>>>>>>> If this is not possible to do it in a simple and explainable way,
>>>>>>>>           
>>>>>>>>             
>>>>>>>>               
>>>>>>>>                 
>>>> please
>>>>   
>>>>     
>>>>       
>>>>         
>>>>>>>>         
>>>>>>>>           
>>>>>>>>             
>>>>>>>>               
>>>>>>>>                 
>>>>> tell me and I'll continue using matlab or searching for the bit of
code
>>>>> which will save me
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>> Anyway, I have to thank you for your interest to help me..
>>>>>>>>
>>>>>>>> Many thanks,
>>>>>>>>
>>>>>>>> Antoine De Pauw
>>>>>>>>
>>>>>>>>   
>>>>>>>>         
>>>>>>>>           
>>>>>>>>             
>>>>>>>>               
>>>>>>>>                 
>>>>>>>>> Antoine De Pauw wrote:
>>>>>>>>>     
>>>>>>>>>           
>>>>>>>>>             
>>>>>>>>>               
>>>>>>>>>                 
>>>>>>>>>                   
>>>>>>>>>> Hi, and thanks for the answer
>>>>>>>>>>
>>>>>>>>>> In fact, what I do is reading a binary file to obtain 3 arrays
>>>>>>>>>>             
>>>>>>>>>>               
>>>>>>>>>>                 
>>>>>>>>>>                   
>>>>>>>>>>                     
>>>>> (Lat,Lon,Val) describing geographic points which are associated by
>>>>>           
> index
>   
>>>>> (like point 1 is Lat[0]:Lon[0] with value Val[0])
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>>>> What I need to do is to plot some points on the map (miller
>>>>>>>>>>               
>>>>>>>>>>                 
>>>>>>>>>>                   
>>>>>>>>>>                     
>>>> projection
>>>>   
>>>>     
>>>>       
>>>>         
>>>>>>>>>>             
>>>>>>>>>>               
>>>>>>>>>>                 
>>>>>>>>>>                   
>>>>>>>>>>                     
>>>>> for most) based on latitude and longitude, to obtain a colour map
>>>>>         
>>>>>           
>> (points
>>   
>>     
>>>>> are unordered, it is from IASI satellite computations)
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>>>> I'm able to create a map, draw simple things on it, etc but the
>>>>>>>>>>             
>>>>>>>>>>               
>>>>>>>>>>                 
>>>>>>>>>>                   
>>>>>>>>>>                     
>>>>> problem I have is any method I try for plotting points is failing,
>>>>>         
>>>>>           
>> either
>>   
>>     
>>>>> pcolor, pcolormesh, imshow, etc.
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>>>> When I found your post on that mailing list, I figured out that
>>>>>>>>>>                     
> you
>   
>>>>>>>>>>             
>>>>>>>>>>               
>>>>>>>>>>                 
>>>>>>>>>>                   
>>>>>>>>>>                     
>>>>> might have the experience and skills to easily explain to me how to
>>>>> manipulate these points and plot them on the map, as there's like no
>>>>>         
>>>>>           
>> help
>>   
>>     
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>> on
>>>>   
>>>>     
>>>>       
>>>>         
>>>>> the web except standard examples...
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>>>> Please tell me if this is possible for you to give me some tips,
>>>>>>>>>>                     
> or
>   
>>>>>>>>>>               
>>>>>>>>>>                 
>>>>>>>>>>                   
>>>>>>>>>>                     
>>>> if
>>>>   
>>>>     
>>>>       
>>>>         
>>>>>>>>>>             
>>>>>>>>>>               
>>>>>>>>>>                 
>>>>>>>>>>                   
>>>>>>>>>>                     
>>>>> it takes too much of your time just advice me some lectures
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>>>> Best regards,
>>>>>>>>>>
>>>>>>>>>> De Pauw Antoine
>>>>>>>>>>   
>>>>>>>>>>       
>>>>>>>>>>             
>>>>>>>>>>               
>>>>>>>>>>                 
>>>>>>>>>>                   
>>>>>>>>>>                     
>>>>>>>>> Antoine:  It would really help to have a script demonstrating your

>>>>>>>>> problem.  It sounds to me like you want to plot markers
>>>>>>>>>                   
> representing
>   
>>>>>>>>>               
>>>>>>>>>                 
>>>>>>>>>                   
>>> a
>>>   
>>>     
>>>       
>>>>>>>>>             
>>>>>>>>>               
>>>>>>>>>                 
>>>>>>>>>                   
>>>>   
>>>>     
>>>>       
>>>>         
>>>>>>>>> set of points - for that you should use the scatter method.
>>>>>>>>>                   
> pcolor,
>   
>>>>>>>>>                 
>>>>>>>>>                   
>>   
>>     
>>>>>>>>> pcolormesh and friends are for plotting gridded data.
>>>>>>>>>
>>>>>>>>> -Jeff
>>>>>>>>>     
>>>>>>>>>           
>>>>>>>>>             
>>>>>>>>>               
>>>>>>>>>                 
>>>>>>>>>                   
>>>>>>>>>>   
>>>>>>>>>>       
>>>>>>>>>>             
>>>>>>>>>>               
>>>>>>>>>>                 
>>>>>>>>>>                   
>>>>>>>>>>                     
>>>>>>>>>>> De Pauw Antoine wrote:
>>>>>>>>>>>     
>>>>>>>>>>>         
>>>>>>>>>>>               
>>>>>>>>>>>                 
>>>>>>>>>>>                   
>>>>>>>>>>>                     
>>>>>>>>>>>                       
>>>>>>>>>>>> Dear sir,
>>>>>>>>>>>>
>>>>>>>>>>>>  
>>>>>>>>>>>>
>>>>>>>>>>>> I&#8217;m currently trying to improve our plotting tools here
at
>>>>>>>>>>>>                   
>>>>>>>>>>>>                     
>>>>>>>>>>>>                       
>>>>>>>>>>>>                         
>>>> the
>>>>   
>>>>     
>>>>       
>>>>         
>>>>>>>>>>>>                 
>>>>>>>>>>>>                   
>>>>>>>>>>>>                     
>>>>>>>>>>>>                       
>>>>>>>>>>>>                         
>>>>> &#8220;Quantum 
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>>>>>> Chemistry and Photophysics&#8221; section of the Université
>>>>>>>>>>>>                         
> Libre
>   
>>>>>>>>>>>>                   
>>>>>>>>>>>>                     
>>>>>>>>>>>>                       
>>>>>>>>>>>>                         
>>>> de
>>>>   
>>>>     
>>>>       
>>>>         
>>>>>>>>>>>>                 
>>>>>>>>>>>>                   
>>>>>>>>>>>>                     
>>>>>>>>>>>>                       
>>>>>>>>>>>>                         
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>>>>>> Bruxelles, and I ran, after many time passed at searching for a

>>>>>>>>>>>> solution, on an explanation from you here: 
>>>>>>>>>>>>
>>>>>>>>>>>>                 
>>>>>>>>>>>>                   
>>>>>>>>>>>>                     
>>>>>>>>>>>>                       
>>>>>>>>>>>>                         
>>>>> http://www.nabble.com/Re:-matplotlib-basemap-question-tt17759370.html
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>>>>>>  
>>>>>>>>>>>>
>>>>>>>>>>>> It seems that you could help me find a solution, as I cannot
>>>>>>>>>>>>                         
> plot
>   
>>>>>>>>>>>>                 
>>>>>>>>>>>>                   
>>>>>>>>>>>>                     
>>>>>>>>>>>>                       
>>>>>>>>>>>>                         
>>>>> any 
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>>>>>> points on maps.
>>>>>>>>>>>>
>>>>>>>>>>>>  
>>>>>>>>>>>>
>>>>>>>>>>>> Could you please tell me what I could do to plot data in a
>>>>>>>>>>>>                         
> simple
>   
>>>>>>>>>>>>                 
>>>>>>>>>>>>                   
>>>>>>>>>>>>                     
>>>>>>>>>>>>                       
>>>>>>>>>>>>                         
>>>>> way, 
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>>>>>> assuming I have 3 unordered arrays containing respectively
>>>>>>>>>>>>                   
>>>>>>>>>>>>                     
>>>>>>>>>>>>                       
>>>>>>>>>>>>                         
>>>> latitude,
>>>>   
>>>>     
>>>>       
>>>>         
>>>>>>>>>>>>                 
>>>>>>>>>>>>                   
>>>>>>>>>>>>                     
>>>>>>>>>>>>                       
>>>>>>>>>>>>                         
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>>>>>> longitude and values to plot?
>>>>>>>>>>>>
>>>>>>>>>>>>  
>>>>>>>>>>>>
>>>>>>>>>>>> Some tips would be very nice from you as any method I have
tried
>>>>>>>>>>>>                     
>>>>>>>>>>>>                       
>>>>>>>>>>>>                         
>>> so
>>>   
>>>     
>>>       
>>>>>>>>>>>>                 
>>>>>>>>>>>>                   
>>>>>>>>>>>>                     
>>>>>>>>>>>>                       
>>>>>>>>>>>>                         
>>>>> far 
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>>>>>> give me some errors&#8230;
>>>>>>>>>>>>
>>>>>>>>>>>>  
>>>>>>>>>>>>
>>>>>>>>>>>> Thank you very much in advance,
>>>>>>>>>>>>
>>>>>>>>>>>>  
>>>>>>>>>>>>
>>>>>>>>>>>> Best regards,
>>>>>>>>>>>>
>>>>>>>>>>>>  
>>>>>>>>>>>>
>>>>>>>>>>>> PS: I give you the code I&#8217;m using currently, missing the
>>>>>>>>>>>>                 
>>>>>>>>>>>>                   
>>>>>>>>>>>>                     
>>>>>>>>>>>>                       
>>>>>>>>>>>>                         
>>>>> plotting part
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>>>>>>  
>>>>>>>>>>>>
>>>>>>>>>>>> from mpl_toolkits.basemap import Basemap
>>>>>>>>>>>>
>>>>>>>>>>>> from numpy import *
>>>>>>>>>>>>
>>>>>>>>>>>> from scipy.io.numpyio import fread
>>>>>>>>>>>>
>>>>>>>>>>>> import matplotlib.pyplot as plt
>>>>>>>>>>>>
>>>>>>>>>>>> import numpy as np
>>>>>>>>>>>>
>>>>>>>>>>>> import os
>>>>>>>>>>>>
>>>>>>>>>>>> import sys
>>>>>>>>>>>>
>>>>>>>>>>>> import array
>>>>>>>>>>>>
>>>>>>>>>>>>  
>>>>>>>>>>>>
>>>>>>>>>>>> fileName="c:/20080821.b56"
>>>>>>>>>>>>
>>>>>>>>>>>>  
>>>>>>>>>>>>
>>>>>>>>>>>> print('preparing map')   
>>>>>>>>>>>>
>>>>>>>>>>>> map = 
>>>>>>>>>>>>
>>>>>>>>>>>>                 
>>>>>>>>>>>>                   
>>>>>>>>>>>>                     
>>>>>>>>>>>>                       
>>>>>>>>>>>>                         
>
Basemap(projection='mill',lat_0=0,lon_0=0,resolution='i',area_thresh=30000.)
>   
>>   
>>     
>>>   
>>>     
>>>       
>>>>   
>>>>     
>>>>       
>>>>         
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>>>>>> map.drawcoastlines(0.5,antialiased=1)
>>>>>>>>>>>>
>>>>>>>>>>>> map.drawmapboundary()
>>>>>>>>>>>>
>>>>>>>>>>>> #map.drawmeridians(np.arange(-180,180,60),linewidth=0.5, 
>>>>>>>>>>>> labels=np.arange(-180,180,60), labelstyle="+/-")
>>>>>>>>>>>>
>>>>>>>>>>>> #map.drawparallels(np.arange(-90,90,30), linewidth=0.5, 
>>>>>>>>>>>> labels=np.arange(-180,180,30), labelstyle="+/-")
>>>>>>>>>>>>
>>>>>>>>>>>> print('reading binary data')
>>>>>>>>>>>>
>>>>>>>>>>>> nbreligne=long(os.stat(fileName)[6])/(8*int(fileName[-2:]))
>>>>>>>>>>>>
>>>>>>>>>>>> Lat=zeros(nbreligne)
>>>>>>>>>>>>
>>>>>>>>>>>> Lon=zeros(nbreligne)
>>>>>>>>>>>>
>>>>>>>>>>>> Val=zeros(nbreligne)
>>>>>>>>>>>>
>>>>>>>>>>>> rawfile=fromfile(open(fileName,'rb'),'d',-1)       
>>>>>>>>>>>>
>>>>>>>>>>>> Lat=rawfile[0:nbreligne]
>>>>>>>>>>>>
>>>>>>>>>>>> Lon=rawfile[nbreligne:nbreligne*2]
>>>>>>>>>>>>
>>>>>>>>>>>> Val=rawfile[nbreligne*21:nbreligne*22]
>>>>>>>>>>>>
>>>>>>>>>>>> print('shifting latitudes and projecting to map')
>>>>>>>>>>>>
>>>>>>>>>>>> i=0
>>>>>>>>>>>>
>>>>>>>>>>>> while i < nbreligne:
>>>>>>>>>>>>
>>>>>>>>>>>>     if(Lon[i]>180):
>>>>>>>>>>>>
>>>>>>>>>>>>         print(Lon[i])
>>>>>>>>>>>>
>>>>>>>>>>>>         Lon[i]-=360
>>>>>>>>>>>>
>>>>>>>>>>>>         print(Lon[i])
>>>>>>>>>>>>
>>>>>>>>>>>>     i+=1
>>>>>>>>>>>>
>>>>>>>>>>>> print('plotting data')
>>>>>>>>>>>>
>>>>>>>>>>>>  
>>>>>>>>>>>>
>>>>>>>>>>>> #plotting code comes here
>>>>>>>>>>>>       
>>>>>>>>>>>>           
>>>>>>>>>>>>                 
>>>>>>>>>>>>                   
>>>>>>>>>>>>                     
>>>>>>>>>>>>                       
>>>>>>>>>>>>                         
>>>>>>>>>>> Antoine:  If you send me a self-contained script that produces
>>>>>>>>>>>                       
> the
>   
>>>>>>>>>>>                     
>>>>>>>>>>>                       
>>   
>>     
>>>>>>>>>>> problem you see, I can help you debug it.  As it stands now, I
>>>>>>>>>>>                     
>>>>>>>>>>>                       
>> have
>>   
>>     
>>>>>>>>>>>               
>>>>>>>>>>>                 
>>>>>>>>>>>                   
>>>>>>>>>>>                     
>>>>>>>>>>>                       
>>>>> very 
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>>>>> little to work with - it could be your plotting commands, or it
>>>>>>>>>>>                 
>>>>>>>>>>>                   
>>>>>>>>>>>                     
>>>>>>>>>>>                       
>>>> could
>>>>   
>>>>     
>>>>       
>>>>         
>>>>>>>>>>>               
>>>>>>>>>>>                 
>>>>>>>>>>>                   
>>>>>>>>>>>                     
>>>>>>>>>>>                       
>>>>> be 
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>>>>> your data.
>>>>>>>>>>>
>>>>>>>>>>> -Jeff
>>>>>>>>>>>     
>>>>>>>>>>>         
>>>>>>>>>>>               
>>>>>>>>>>>                 
>>>>>>>>>>>                   
>>>>>>>>>>>                     
>>>>>>>>>>>                       
>>>>>>>>>>>>  
>>>>>>>>>>>>
>>>>>>>>>>>> print('saving map')       
>>>>>>>>>>>>
>>>>>>>>>>>> plt.savefig("testfig.png",dpi=600)
>>>>>>>>>>>>
>>>>>>>>>>>> print('done')
>>>>>>>>>>>>
>>>>>>>>>>>>  
>>>>>>>>>>>>
>>>>>>>>>>>> *Antoine De Pauw*
>>>>>>>>>>>> Collaborateur de recherches, Informatique - Research
>>>>>>>>>>>>                       
>>>>>>>>>>>>                         
>> collaborator,
>>   
>>     
>>>>>>>>>>>>                 
>>>>>>>>>>>>                   
>>>>>>>>>>>>                     
>>>>>>>>>>>>                       
>>>>>>>>>>>>                         
>>>>> IT
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>>>>>> Laboratoire de chimie quantique et photophysique - Quantum
>>>>>>>>>>>>                   
>>>>>>>>>>>>                     
>>>>>>>>>>>>                       
>>>>>>>>>>>>                         
>>>> chemistry
>>>>   
>>>>     
>>>>       
>>>>         
>>>>>>>>>>>>                 
>>>>>>>>>>>>                   
>>>>>>>>>>>>                     
>>>>>>>>>>>>                       
>>>>>>>>>>>>                         
>>>>> and 
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>>>>>>>>> photophysics laboratory
>>>>>>>>>>>> *Université Libre de Bruxelles - ULB <http://ww.ulb.ac.be/>*
>>>>>>>>>>>>
>>>>>>>>>>>>  
>>>>>>>>>>>>
>>>>>>>>>>>>       
>>>>>>>>>>>>           
>>>>>>>>>>>>                 
>>>>>>>>>>>>                   
>>>>>>>>>>>>                     
>>>>>>>>>>>>                       
>>>>>>>>>>>>                         
>>>>>>>>>>> -- 
>>>>>>>>>>> Jeffrey S. Whitaker         Phone  : (303)497-6313
>>>>>>>>>>> Meteorologist               FAX    : (303)497-6449
>>>>>>>>>>> NOAA/OAR/PSD  R/PSD1        Email  : [EMAIL PROTECTED]
>>>>>>>>>>> 325 Broadway                Office : Skaggs Research Cntr 1D-113
>>>>>>>>>>> Boulder, CO, USA 80303-3328 Web    : http://tinyurl.com/5telg
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>     
>>>>>>>>>>>         
>>>>>>>>>>>               
>>>>>>>>>>>                 
>>>>>>>>>>>                   
>>>>>>>>>>>                     
>>>>>>>>>>>                       
>>>>>>>>>>   
>>>>>>>>>>       
>>>>>>>>>>             
>>>>>>>>>>               
>>>>>>>>>>                 
>>>>>>>>>>                   
>>>>>>>>>>                     
>>>>>>>>> -- 
>>>>>>>>> Jeffrey S. Whitaker         Phone : (303)497-6313
>>>>>>>>> NOAA/OAR/CDC  R/PSD1        FAX   : (303)497-6449
>>>>>>>>> 325 Broadway                Boulder, CO, USA 80305-3328
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>     
>>>>>>>>>           
>>>>>>>>>             
>>>>>>>>>               
>>>>>>>>>                 
>>>>>>>>>                   
>>>>>>>>   
>>>>>>>>         
>>>>>>>>           
>>>>>>>>             
>>>>>>>>               
>>>>>>>>                 
>>>>>>> -- 
>>>>>>> Jeffrey S. Whitaker         Phone : (303)497-6313
>>>>>>> NOAA/OAR/CDC  R/PSD1        FAX   : (303)497-6449
>>>>>>> 325 Broadway                Boulder, CO, USA 80305-3328
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>       
>>>>>>>         
>>>>>>>           
>>>>>>>             
>>>>>>>               
>>>>>>     
>>>>>>       
>>>>>>         
>>>>>>           
>>>>>>             
>>>>>   
>>>>>     
>>>>>       
>>>>>         
>>>>>           
>>>>   
>>>>     
>>>>       
>>>>         
>>>   
>>>     
>>>       
>>   
>>     
>
>
>   


-- 
Jeffrey S. Whitaker         Phone : (303)497-6313
NOAA/OAR/CDC  R/PSD1        FAX   : (303)497-6449
325 Broadway                Boulder, CO, USA 80305-3328


-------------------------------------------------------------------------
This SF.Net email is sponsored by the Moblin Your Move Developer's challenge
Build the coolest Linux based applications with Moblin SDK & win great prizes
Grand prize is a trip for two to an Open Source event anywhere in the world
http://moblin-contest.org/redirect.php?banner_id=100&url=/
_______________________________________________
Matplotlib-users mailing list
Matplotlib-users@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/matplotlib-users

Reply via email to