How to color a contour of two curves?

Hi, I'm trying to color a contour between two function curves, the problem is that just the two curves appear, without a colored contour. And this message appears when i am running.

Warning: Function behaves unexpectedly on array inputs. To improve performance, properly vectorize

your function to return an output with the same size and shape as the input arguments.

Answer 1

[Star Strider]

I am not certain what you want.

Try this —

% Diagramme de coexistence avec des contours colorés
% clc; clear; close all;

% Définir les limites des axes
Rs_min = 0; Rs_max = 5; % Intervalle pour Rs
Rh_min = 0; Rh_max = 5; % Intervalle pour Rh
% Générer une grille de points dans le plan (Rs, Rh)
[Rs, Rh] = meshgrid(linspace(Rs_min, Rs_max, 500), linspace(Rh_min, Rh_max, 500));
% Définir les seuils critiques
Rs1 = 1; % Seuil critique pour Rs
Rh1 = 1; % Seuil critique pour Rh

% Calculer les régions :
extinction = (Rs <= Rs1) & (Rh <= Rh1); % Dominace E_0
region1 = (Rs > Rs1) & (Rh <= Rh1); % Domination E*_1 
region2 = (Rh > Rh1) & (Rs <= Rs1); % Domination E*_2
coexistence = (Rs > Rs1) & (Rh > Rh1); % Coexistence E*

% Créer une matrice de catégories pour les régions
regions = zeros(size(Rs));
regions(region1) = 1; % Code 1 : Domination Espèce E*_1
regions(region2) = 2; % Code 2 : Domination Espèce E*_2
regions(coexistence) = 3; % Code 3 : Coexistence E*
regions(extinction) = 4; % Code 4 : E_0
% Ajouter une relation entre R1 et R2 (par exemple, R2 = 1 / R1)
delta = 0.0001;  % Taux de mortalité
delta_S = 0.0005;     % Taux de mort de Syphilis.
delta_H = 0.00004;
Lambda =4.04 *100; 
gamma=1.7;
phi_S =0.0006;
phi_H =0.00002;
c1 = 1;
c2=2 ;
theta1 =11 ;
theta2 = 5;
alpha = 0.4;
beta = 0.11;
rho1 = 0.5;
rho2= 1.5;
rho3=1.5;

y_1=gamma+delta+delta_S;
y_2=alpha+delta+delta_H;
y_4=rho1*gamma+rho2*alpha+delta+delta_S+delta_H;

m=delta./(delta+delta_S);
%expression de Rh en fonction de Rs
f = @(Rs) (((theta1*(Rs-1)*m*y_1+y_2)*y_4 )-theta1*(Rs-1)*m*y_1*rho1*gamma)/(((y_2*y_4)./ Rs)+c1*theta1*theta2*Rs*(1- 1 ./ Rs)^2* m^2*y_1*y_2+c1*theta2*m*(y_2)^2*(1- 1 ./ Rs)+rho1*gamma*theta2*m*(1- 1 ./ Rs)+c1*theta1*m*y_1*y_2*(1- 1 ./ Rs));
g=@(Rs) Rs*(theta2*delta*(Rs- 1 )+y_1)*y_4*y_2/(y_1*y_2*y_4+theta1*c2*delta*y_1* (Rs- 1 )*(theta2*delta*(Rs-1)+y_1)+theta2*c2*delta*(Rs-1)*y_1*y_2);
%t=@(Rs) Rs;

f_values = f(Rs);         % Valeurs de la fonction `f` sur les points `x`

Warning: Matrix is singular, close to singular or badly scaled. Results may be inaccurate. RCOND = NaN.

g_values = g(Rs);% Valeurs de la fonction `g` sur les points `x`

Warning: Matrix is singular to working precision.

X = [Rs, fliplr(Rs)];  
Y = [f_values, fliplr(g_values)]; 
% Afficher la formule de la fonction symbolique
disp('La formule de la fonction est :');

La formule de la fonction est :

disp(f);

    @(Rs)(((theta1*(Rs-1)*m*y_1+y_2)*y_4)-theta1*(Rs-1)*m*y_1*rho1*gamma)/(((y_2*y_4)./Rs)+c1*theta1*theta2*Rs*(1-1./Rs)^2*m^2*y_1*y_2+c1*theta2*m*(y_2)^2*(1-1./Rs)+rho1*gamma*theta2*m*(1-1./Rs)+c1*theta1*m*y_1*y_2*(1-1./Rs))

disp(g);

    @(Rs)Rs*(theta2*delta*(Rs-1)+y_1)*y_4*y_2/(y_1*y_2*y_4+theta1*c2*delta*y_1*(Rs-1)*(theta2*delta*(Rs-1)+y_1)+theta2*c2*delta*(Rs-1)*y_1*y_2)

%disp(t);
figure(1);
hold on;
fill(X, Y, 'cyan', 'FaceAlpha', 0.5, 'EdgeColor', 'none'); % Remplissage de la région
fp1 = fplot( f, [1, Rs_max], 'k-', 'LineWidth', 0.5);% Courbe Rh en fonction de Rs

Warning: Function behaves unexpectedly on array inputs. To improve performance, properly vectorize your function to return an output with the same size and shape as the input arguments.

fp2 = fplot( g, [1, Rs_max], 'r--', 'LineWidth', 0.5);%courbe Rs en fct Rh( on adaptant meme nota pour tracer la recipro

Warning: Function behaves unexpectedly on array inputs. To improve performance, properly vectorize your function to return an output with the same size and shape as the input arguments.

x1 = fp1.XData;
y1 = fp1.YData;
x2 = fp2.XData;
y2 = fp2.YData;
patch([x1 flip(x2)], [y1 flip(y2)], 'g')                        % Plot Green ‘patch’
%fplot( t, [1, Rs_max], 'b-', 'LineWidth', 0.5);
% Ajouter des lignes critiques
plot([Rs1 Rs1], [Rh_min Rh_max], 'k--', 'LineWidth', 0.5); % Ligne verticale Rs1
plot([Rs_min Rs_max], [Rh1 Rh1], 'k--', 'LineWidth', 0.5); % Ligne horizontale Rh1
% Ajuster l'apparence
xlabel('R_s');
ylabel('R_h');
hold off

.

[Khadija]

Thank you Mr. Star,

You always save me, I would like to understand the operating principle of the 'patch' function as well as 'flip'.

If I want to insert points or writing on the colored part, can you recommend a program that does the same thing!!

[Star Strider]

As always, my pleasure!

First, the ‘secret’ of using the patch function is to create a closed curve. This means that the ‘x’ values must go first in one direction, then turn back essentiially to the beginning So for example, that would be [1 2 3] for ‘x1’, and then the flip function would reverse ‘x2’. So [x1 flip(x2)] in this example would produce [1 2 3 5 4 2] for the ‘x’ vector argument to patch. The ‘y’ vector argument has to do the same sort of thing, for example [0 2 3] and then since those values would be expected to be different, the second vector would be the flipped version of [5 9 8] that being [8 9 5]. (None of the vectors need to have the same values as the others..) The patch function will connect any unconnected lines at the ends, so there is no need to do that specifically in your code.

To write someething in that region would use the text function. (I also use the compose function here.)

Combining both of those in this example —

x1 = [1 2 3];
y1 = [0 2 3];

x2 = [2 4 5];
y2 = [5 9 8];

figure
patch([x1 flip(x2)], [y1 flip(y2)], 'g')
grid
axis('padded')
c = compose('(%.1f, %.1f)', [[x1 flip(x2)]; [y1 flip(y2)]].')       % Create A Cell Array To Use With ‘text’

c = 6x1 cell array
    {'(1.0, 0.0)'}
    {'(2.0, 2.0)'}
    {'(3.0, 3.0)'}
    {'(5.0, 8.0)'}
    {'(4.0, 9.0)'}
    {'(2.0, 5.0)'}

text([x1 flip(x2)], [y1 flip(y2)], c, HorizontalAlignment='left', VerticalAlignment='middle')
text(2.2, 3.5, "Completed ‘patch’ Plot", FontWeight='bold', Color='r', Rotation=35)
xlabel('X')
ylabel('Y')
title('Example ‘patch’ Plot Also Using ‘text’')

This should give you an idea of how the patch function works, and how to print text on the patch.

.

[Walter Roberson]

f = @(Rs) (((theta1*(Rs-1)*m*y_1+y_2)*y_4 )-theta1*(Rs-1)*m*y_1*rho1*gamma)/(((y_2*y_4)./ Rs)+c1*theta1*theta2*Rs*(1- 1 ./ Rs)^2* m^2*y_1*y_2+c1*theta2*m*(y_2)^2*(1- 1 ./ Rs)+rho1*gamma*theta2*m*(1- 1 ./ Rs)+c1*theta1*m*y_1*y_2*(1- 1 ./ Rs));

You have an "/" operator there, and the left hand side includes Rs and the right hand side includes Rs . When Rs is non-scalar, that is a (non-scalar1)/(non-scalar2) . Which is the "Matrix Right Divide" operation, roughly equivalent to (non-scalar1) * pinv(non-scalar2) where * is algebraic matrix multiplication.

You need to code the ./ operator instead of the / operator.

Also, the expression (1- 1 ./ Rs)^2 needs to be (1- 1 ./ Rs).^2

[Khadija]

Thank you so much!!

[Khadija]

What is this command for?

text([x1 flip(x2)], [y1 flip(y2)], c, HorizontalAlignment='left', VerticalAlignment='middle')

since the latter gives the display on the colored area

text(2.2, 3.5, "Completed ‘patch’ Plot", FontWeight='bold', Color='r', Rotation=35)

[Star Strider]

As always, my pleasure!

This comnand:

text([x1 flip(x2)], [y1 flip(y2)], c, HorizontalAlignment='left', VerticalAlignment='middle')

plots the coordinate values next to the plotted points.

Adding arrows makes the approach more understandable —

x1 = [1 2 3];
y1 = [0 2 3];

x2 = [2 4 5];
y2 = [5 9 8];

figure
patch([x1 flip(x2)], [y1 flip(y2)], 'g')
grid
axis('padded')
c = compose('(%.1f, %.1f)', [[x1 flip(x2)]; [y1 flip(y2)]].')       % Create A Cell Array To Use With ‘text’

c = 6x1 cell array
    {'(1.0, 0.0)'}
    {'(2.0, 2.0)'}
    {'(3.0, 3.0)'}
    {'(5.0, 8.0)'}
    {'(4.0, 9.0)'}
    {'(2.0, 5.0)'}

text([x1 flip(x2)], [y1 flip(y2)], c, HorizontalAlignment='left', VerticalAlignment='middle')
text(2.2, 3.5, "Completed ‘patch’ Plot", FontWeight='bold', Color='r', Rotation=35)
xlabel('X')
ylabel('Y')
title('Example ‘patch’ Plot Also Using ‘text’')

xapf = @(x,pos,xl) pos(3)*(x-min(xl))/diff(xl)+pos(1);                % 'x' Annotation Position Function
yapf = @(y,pos,yl) pos(4)*(y-min(yl))/diff(yl)+pos(2);                % 'y' Annotation Position Function
xl = xlim;
yl = ylim;
pos = gca().Position;
xv = [x1 flip(x2) x1(1)];
yv = [y1 flip(y2) y1(1)];
for k = 1:numel(xv)-1
    annotation('arrow', xapf([xv(k) xv(k+1)],pos,xlim), yapf([yv(k) yv(k+1)],pos,ylim))
end

The annotation arrows demonstrate the approach to creating the patch object. This creates a continuous closed region, going in the direction of the arrows.

.

[Khadija]

thank you very much; if I want to surround the text inside "Completed ‘patch’ Plot" with a circle, what command should I use?

[Star Strider]

As always, my pleasure!

For the circle (or ellipse), see Create Ellipse Annotation and use:

xapf = @(x,pos,xl) pos(3)*(x-min(xl))/diff(xl)+pos(1); % 'x' Annotation Position Function

yapf = @(y,pos,yl) pos(4)*(y-min(yl))/diff(yl)+pos(2); % 'y' Annotation Position Function

xl = xlim;

yl = ylim;

pos = gca().Position;

similarly to tthe way I did it to create the ellipse or circle.

Also see Ellipse Properties since the arguments are not as straightforward as I initially thought they would be.

Illustrating —

x1 = [1 2 3];
y1 = [0 2 3];

x2 = [2 4 5];
y2 = [5 9 8];

figure
patch([x1 flip(x2)], [y1 flip(y2)], 'g')
grid
axis('padded')
% c = compose('(%.1f, %.1f)', [[x1 flip(x2)]; [y1 flip(y2)]].')       % Create A Cell Array To Use With ‘text’
% text([x1 flip(x2)], [y1 flip(y2)], c, HorizontalAlignment='left', VerticalAlignment='middle')
text(2.2, 3.5, "Completed ‘patch’ Plot", FontWeight='bold', Color='r', Rotation=35)
xlabel('X')
ylabel('Y')
title('Example ‘patch’ Plot Also Using ‘text’')

xapf = @(x,pos,xl) pos(3)*(x-min(xl))/diff(xl)+pos(1);                % 'x' Annotation Position Function
yapf = @(y,pos,yl) pos(4)*(y-min(yl))/diff(yl)+pos(2);                % 'y' Annotation Position Function
xl = xlim;
yl = ylim;
pos = gca().Position;
annotation('ellipse', [xapf(2.2,pos,xlim), yapf(2.0,pos,ylim) 0.4 0.2], Rotation=35, Color='r', LineWidth=2)

Note that the second argument to the annotation function to create an ellipse is:

[left x-coordinate, lower y-coordinate, width, height]

so you can use ‘xapf’ and ‘yapf’ for the first two (these are correct before rotating it), however you do not necessarily have to use them to create the last two. You will simply have to experiment with the last two to get the result you want. I suggest initially creating it without the rotatioon, then add the rotation and tweak the arguments to get the result you want. The last two elements in that vector control the aspect ratio, so make them equal to create a circle, and different to create an ellipse.

EDIT — (9 Dec 2024 at 13:23)

You can also use my functions to create a realistic aspect ratio, and to correct the coordinates iif you rotate it —

x1 = [1 2 3];
y1 = [0 2 3];

x2 = [2 4 5];
y2 = [5 9 8];

figure
patch([x1 flip(x2)], [y1 flip(y2)], 'g')
grid
axis('padded')
% c = compose('(%.1f, %.1f)', [[x1 flip(x2)]; [y1 flip(y2)]].')       % Create A Cell Array To Use With ‘text’
% text([x1 flip(x2)], [y1 flip(y2)], c, HorizontalAlignment='left', VerticalAlignment='middle')
text(2.2, 3.5, "Completed ‘patch’ Plot", FontWeight='bold', Color='r', Rotation=35)
xlabel('X')
ylabel('Y')
title('Example ‘patch’ Plot Also Using ‘text’')

xapf = @(x,pos,xl) pos(3)*(x-min(xl))/diff(xl)+pos(1);                % 'x' Annotation Position Function
yapf = @(y,pos,yl) pos(4)*(y-min(yl))/diff(yl)+pos(2);                % 'y' Annotation Position Function
xl = xlim;
yl = ylim;
pos = gca().Position;
annotation('ellipse', [xapf(2.2,pos,xlim), yapf(3.5*sind(35),pos,ylim) diff(xapf([2.2 4.2]/cosd(35),pos,xlim)), diff(yapf([1 3]/cosd(35),pos,ylim))], Rotation=35, Color='r', LineWidth=2)

The trigonometric function arguments are the same as the Rotation argument.

If you do not rotate the ellipse, use this annotation call instead:

annotation('ellipse', [xapf(2.2,pos,xlim), yapf(3.5,pos,ylim) diff(xapf([2.2 4.0],pos,xlim)), diff(yapf([1 3],pos,ylim))], Color='r', LineWidth=2)

It may be necessary to tweak the first element of the vector( the x-coordinate of the ellipse) to positiion it correctly. The last two elements in the vector (that define the aspect ratio) are now defined in terms of the x and y units of the plot.

.

[Khadija]

Hi Mr star,

I need more explanation for these two functions that you defined to surround the text, because I will use them several times and in several different locations in the same figure, I am trying to surround geometric points that I will display in this graph.

the arguments pos() and xl (where do their values come from?)

xapf = @(x,pos,xl) pos(3)*(x-min(xl))/diff(xl)+pos(1);                % 'x' Annotation Position Function
yapf = @(y,pos,yl) pos(4)*(y-min(yl))/diff(yl)+pos(2);                % 'y' Annotation Position Function
xl = xlim;
yl = ylim;
pos = gca().Position;

[Star Strider]

The ‘xapf’ and ‘yapf’ functions take the values derived from the figure and calculate normalised coordinate values that are calcualted from the ‘x’ and ‘y’ values you provide to them.

I defined the functions (anonymous functions) first, then some of their arguments. The ‘pos’ argument is determined by the Position property of the figure. The other two (‘xl’ and ‘yl’) are the respective axis limits, also derived from the figure. The annotation call then uses their results (outputs), calculated from the ‘x’ and ‘y’ values that you define. Once the ‘xapf’ and ‘yapf’ functions and their argumeents are defined, you only need to call the ‘xapf’ and ‘yapf’ functions in subsequent annotation calls for each figure.

Please consult the annotation documentation, because (as I learned while doing this), different annotation types have different argument requirements. Some simply require the relevant ‘x’ and ‘y’ values (normalised as calculated by ‘xapf’ and ‘yapf’) and others (such as 'ellipse'), require ‘x’ and ‘y’ values for the first two arguments, and width and height relative values for the last two.

.

[Khadija]

Does the argument 'pos' give the position of the text "Completed ‘patch’ Plot" from the figure?

and why use xlim and ylim ?

excuse my stupid questions!!

I'm trying to better understand and manipulate graphics.

Thanks again.

[Star Strider]

As always, my pleasure!

You questions are definitely not stupid!

The ‘x’ and ‘y’ values the annotation('ellipse', ... ) call uses are the same as the starting position of the “Completed ‘patch’ plot” text object, however the resemblance ends there (and that does not always have to be the situation, it just works here). The ‘x’ and ‘y’ values and ‘pos’ are not the same.

The ‘pos’ argument provides the ‘Position’ property of the axes using the gca (get current axes) function. the xlim and ylim calls return the axis limits and provide them to the ‘xapf’ and ‘‘yapf’ as well, since the functions need all that information to calculate the normalizsed coordinates that the annotation object uses. You can see how the ‘xapf’ and ‘‘yapf’ functions use those arguments by looking at theiir codes (that are essentially the same). My functions scale the ‘x’ and ‘y’ values you give them, using the other arguments, to provide the normalised coordinates in the axes that the annotation function needs.

.

[Khadija]

Thank you for your patience!!

now it's pretty clear,

one last question if you don't mind. I divided my graph into regions to color, one of the regions is subdivided by curves of the functions that I used to color their contours. the problem that I can't overcome is that region 3 keeps the background color (white) without the curves appearing.

[Star Strider]

As always, my pleasure!

I don’t mind at all!

I am not certain what the problem is, so I am venturing a guess. One possible solution is to specify the FaceAlpha (transparency) of the white patch as some lower value (opaque is 1, fully transparent is 0, the value can be anything between and including those values), another is to plot the patch first and then draw the curves. You can also specify EdgeAlpha and EdgeColor. See the patch documentation for details.

.

[Khadija]

Thank you so much!!

I solved the problem, your instructions were very helpful, you are an angel!!

[Star Strider]

As always, my pleasure!

I very much appreciate your compliment!